[FIR IDE] Initial descriptor-based implementation of the Analysis API

analysis/analysis-api-fe10/build.gradle.kts

@@ -0,0 +1,44 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    implementation(project(":core:descriptors.jvm"))
+    implementation(project(":compiler:frontend"))
+    implementation(project(":compiler:frontend.java"))
+    implementation(project(":analysis:analysis-api-impl-base"))
+
+    implementation(project(":compiler:backend"))
+    implementation(project(":compiler:backend.jvm"))
+    implementation(project(":compiler:backend-common"))
+    implementation(project(":compiler:backend.common.jvm"))
+
+    testApiJUnit5()
+    testImplementation(project(":analysis:analysis-api-providers"))
+    testImplementation(projectTests(":compiler:tests-common"))
+    testImplementation(projectTests(":compiler:test-infrastructure-utils"))
+    testImplementation(projectTests(":compiler:test-infrastructure"))
+    testImplementation(projectTests(":compiler:tests-common-new"))
+    testImplementation(projectTests(":analysis:analysis-api-impl-barebone"))
+    testImplementation(projectTests(":analysis:analysis-api-impl-base"))
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" { projectDefault() }
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
+    kotlinOptions {
+        freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
+    }
+}
+
+projectTest(jUnit5Enabled = true) {
+    dependsOn(":dist")
+    workingDir = rootDir
+    useJUnitPlatform()
+}
+
+testsJar()

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors
+
+import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.components.*
+import org.jetbrains.kotlin.analysis.api.descriptors.components.*
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProvider
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+
+@Suppress("LeakingThis")
+abstract class KtFe10AnalysisSession(val contextElement: KtElement, token: ValidityToken) : KtAnalysisSession(token) {
+    override val smartCastProviderImpl: KtSmartCastProvider = KtFe10SmartCastProvider(this)
+    override val diagnosticProviderImpl: KtDiagnosticProvider = KtFe10DiagnosticProvider(this)
+    override val scopeProviderImpl: KtScopeProvider = KtFe10ScopeProvider(this)
+    override val containingDeclarationProviderImpl: KtSymbolContainingDeclarationProvider = KtFe10SymbolContainingDeclarationProvider(this)
+    override val symbolProviderImpl: KtSymbolProvider = KtFe10SymbolProvider(this)
+    override val callResolverImpl: KtCallResolver = KtFe10CallResolver(this)
+    override val completionCandidateCheckerImpl: KtCompletionCandidateChecker = KtFe10CompletionCandidateChecker(this)
+    override val symbolDeclarationOverridesProviderImpl: KtSymbolDeclarationOverridesProvider = KtFe10SymbolDeclarationOverridesProvider(this)
+    override val referenceShortenerImpl: KtReferenceShortener = KtFe10ReferenceShortener(this)
+    override val symbolDeclarationRendererProviderImpl: KtSymbolDeclarationRendererProvider = KtFe10SymbolDeclarationRendererProvider(this)
+    override val expressionTypeProviderImpl: KtExpressionTypeProvider = KtFe10ExpressionTypeProvider(this)
+    override val psiTypeProviderImpl: KtPsiTypeProvider = KtFe10PsiTypeProvider(this)
+    override val typeProviderImpl: KtTypeProvider = KtFe10TypeProvider(this)
+    override val typeInfoProviderImpl: KtTypeInfoProvider = KtFe10TypeInfoProvider(this)
+    override val subtypingComponentImpl: KtSubtypingComponent = KtFe10SubtypingComponent(this)
+    override val expressionInfoProviderImpl: KtExpressionInfoProvider = KtFe10ExpressionInfoProvider(this)
+    override val compileTimeConstantProviderImpl: KtCompileTimeConstantProvider = KtFe10CompileTimeConstantProvider(this)
+    override val visibilityCheckerImpl: KtVisibilityChecker = KtFe10VisibilityChecker(this)
+    override val overrideInfoProviderImpl: KtOverrideInfoProvider = KtFe10OverrideInfoProvider(this)
+    override val inheritorsProviderImpl: KtInheritorsProvider = KtFe10InheritorsProvider(this)
+    override val typesCreatorImpl: KtTypeCreator = KtFe10TypeCreator(this)
+    override val samResolverImpl: KtSamResolver = KtFe10SamResolver(this)
+    override val importOptimizerImpl: KtImportOptimizer = KtFe10ImportOptimizer(this)
+    override val jvmTypeMapperImpl: KtJvmTypeMapper = KtFe10JvmTypeMapper(this)
+    override val symbolInfoProviderImpl: KtSymbolInfoProvider = KtFe10SymbolInfoProvider(this)
+
+    abstract val resolveSession: ResolveSession
+    abstract val deprecationResolver: DeprecationResolver
+
+    abstract fun analyze(element: KtElement, mode: AnalysisMode = AnalysisMode.FULL): BindingContext
+
+    abstract fun getOrigin(file: VirtualFile): KtSymbolOrigin
+
+    enum class AnalysisMode {
+        FULL,
+        PARTIAL_WITH_DIAGNOSTICS,
+        PARTIAL
+    }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors
+
+import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityTokenFactory
+import org.jetbrains.kotlin.psi.KtElement
+
+@InvalidWayOfUsingAnalysisSession
+class KtFe10AnalysisSessionProvider : KtAnalysisSessionProvider() {
+    @InvalidWayOfUsingAnalysisSession
+    override fun getAnalysisSession(contextElement: KtElement, factory: ValidityTokenFactory): KtAnalysisSession {
+        return KtFe10AnalysisSession(contextElement, factory.create(contextElement.project))
+    }
+
+    @InvalidWayOfUsingAnalysisSession
+    override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession {
+        if (contextSymbol is KtFe10Symbol) {
+            return contextSymbol.analysisSession
+        } else {
+            val contextElement = contextSymbol.psi
+            if (contextElement != null) {
+                return KtFe10AnalysisSession(contextElement, contextSymbol.token)
+            }
+        }
+
+        throw IllegalArgumentException("Unsupported symbol kind: $contextSymbol")
+    }
+
+    override fun clearCaches() {}
+}

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

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.calls.*
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescPropertyGetterSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescPropertySetterSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.callableId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.diagnostics.KtNonBoundToPsiErrorDiagnostic
+import org.jetbrains.kotlin.analysis.api.impl.base.components.AbstractKtCallResolver
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtVariableLikeSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.idea.references.readWriteAccessWithFullExpressionWithPossibleResolve
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.findAssignment
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+import org.jetbrains.kotlin.resolve.descriptorUtil.isAnnotationConstructor
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+
+internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSession) : AbstractKtCallResolver() {
+    private companion object {
+        private const val UNRESOLVED_CALL_MESSAGE = "Unresolved call"
+    }
+
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun resolveAccessorCall(call: KtSimpleNameExpression): KtCall? {
+        val bindingContext = analysisSession.analyze(call, KtFe10AnalysisSession.AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+        val resolvedCall = call.getResolvedCall(bindingContext) ?: return null
+        val resultingDescriptor = resolvedCall.resultingDescriptor
+
+        if (resultingDescriptor is PropertyDescriptor) {
+            @Suppress("DEPRECATION")
+            val access = call.readWriteAccessWithFullExpressionWithPossibleResolve(
+                readWriteAccessWithFullExpressionByResolve = { null }
+            ).first
+
+            val setterValue = findAssignment(call)?.right
+            val accessorSymbol = when (resultingDescriptor) {
+                is SyntheticJavaPropertyDescriptor -> {
+                    when {
+                        access.isWrite -> resultingDescriptor.setMethod?.let { KtFe10DescFunctionSymbol(it, analysisSession) }
+                        access.isRead -> KtFe10DescFunctionSymbol(resultingDescriptor.getMethod, analysisSession)
+                        else -> null
+                    }
+                }
+                else -> {
+                    when {
+                        access.isWrite -> resultingDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisSession) }
+                        access.isRead -> resultingDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisSession) }
+                        else -> null
+                    }
+                }
+            }
+
+            if (accessorSymbol != null) {
+                val target = when {
+                    !access.isWrite || setterValue != null -> KtSuccessCallTarget(accessorSymbol, token)
+                    else -> {
+                        val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, "Setter value is missing", token)
+                        KtErrorCallTarget(listOf(accessorSymbol), diagnostic, token)
+                    }
+                }
+
+                val argumentMapping = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
+                if (access.isWrite && setterValue != null) {
+                    val setterParameterSymbol = accessorSymbol.valueParameters.single()
+                    argumentMapping[setterValue] = setterParameterSymbol
+                }
+
+                return KtFunctionCall(argumentMapping, target, KtSubstitutor.Empty(token), token)
+            }
+        }
+
+        return null
+    }
+
+    override fun resolveCall(call: KtCallElement): KtCall? = withValidityAssertion {
+        return resolveCall(call, isUsualCall = true)
+    }
+
+    override fun resolveCall(call: KtBinaryExpression): KtCall? = withValidityAssertion {
+        return resolveCall(call, isUsualCall = false)
+    }
+
+    override fun resolveCall(call: KtUnaryExpression): KtCall? = withValidityAssertion {
+        return resolveCall(call, isUsualCall = false)
+    }
+
+    override fun resolveCall(call: KtArrayAccessExpression): KtCall? = withValidityAssertion {
+        return resolveCall(call, isUsualCall = false)
+    }
+
+    /**
+     * Analyze the given call element (a function call, unary/binary operator call, or convention call).
+     *
+     * @param call the call element to analyze.
+     * @param isUsualCall `true` if the call is a usual function call (`foo()` or `foo {}`).
+     */
+    private fun resolveCall(call: KtElement, isUsualCall: Boolean): KtCall? {
+        val bindingContext = analysisSession.analyze(call, KtFe10AnalysisSession.AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+        val resolvedCall = call.getResolvedCall(bindingContext) ?: return getUnresolvedCall(call)
+
+        val argumentMapping = createArgumentMapping(resolvedCall)
+
+        fun getTarget(targetSymbol: KtFunctionLikeSymbol): KtCallTarget {
+            if (resolvedCall.status == ResolutionStatus.SUCCESS) {
+                return KtSuccessCallTarget(targetSymbol, token)
+            }
+
+            val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+            return KtErrorCallTarget(listOf(targetSymbol), diagnostic, token)
+        }
+
+        val targetDescriptor = resolvedCall.resultingDescriptor
+
+        val callableSymbol = targetDescriptor.toKtCallableSymbol(analysisSession) as? KtFunctionLikeSymbol ?: return null
+
+        if (resolvedCall is VariableAsFunctionResolvedCall) {
+            val variableDescriptor = resolvedCall.variableCall.resultingDescriptor
+            val variableSymbol = variableDescriptor.toKtCallableSymbol(analysisSession) as? KtVariableLikeSymbol ?: return null
+
+            val substitutor = KtSubstitutor.Empty(token)
+            return if (resolvedCall.functionCall.resultingDescriptor.callableId in kotlinFunctionInvokeCallableIds) {
+                KtFunctionalTypeVariableCall(variableSymbol, argumentMapping, getTarget(callableSymbol), substitutor, token)
+            } else {
+                KtVariableWithInvokeFunctionCall(variableSymbol, argumentMapping, getTarget(callableSymbol), substitutor, token)
+            }
+        }
+
+        if (call is KtConstructorDelegationCall) {
+            return KtDelegatedConstructorCall(argumentMapping, getTarget(callableSymbol), call.kind, token)
+        }
+
+        if (isUsualCall) {
+            if (targetDescriptor.isAnnotationConstructor()) {
+                return KtAnnotationCall(argumentMapping, getTarget(callableSymbol), token)
+            }
+        }
+
+        return KtFunctionCall(argumentMapping, getTarget(callableSymbol), KtSubstitutor.Empty(token), token)
+    }
+
+    private fun getUnresolvedCall(call: KtElement): KtCall? {
+        return when (call) {
+            is KtSuperTypeCallEntry -> {
+                val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+                val target = KtErrorCallTarget(emptyList(), diagnostic, token)
+                KtDelegatedConstructorCall(LinkedHashMap(), target, KtDelegatedConstructorCallKind.SUPER_CALL, token)
+            }
+            is KtConstructorDelegationCall -> {
+                val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+                val target = KtErrorCallTarget(emptyList(), diagnostic, token)
+                return KtDelegatedConstructorCall(LinkedHashMap(), target, call.kind, token)
+            }
+            else -> null
+        }
+    }
+
+    private val KtConstructorDelegationCall.kind: KtDelegatedConstructorCallKind
+        get() = when {
+            isCallToThis -> KtDelegatedConstructorCallKind.THIS_CALL
+            else -> KtDelegatedConstructorCallKind.SUPER_CALL
+        }
+
+    private fun createArgumentMapping(resolvedCall: ResolvedCall<*>): LinkedHashMap<KtExpression, KtValueParameterSymbol> {
+        val result = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
+        for ((parameter, arguments) in resolvedCall.valueArguments) {
+            val parameterSymbol = KtFe10DescValueParameterSymbol(parameter, analysisSession)
+
+            for (argument in arguments.arguments) {
+                val expression = argument.getArgumentExpression() ?: continue
+                result[expression] = parameterSymbol
+            }
+        }
+        return result
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtCompileTimeConstantProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
+import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
+import org.jetbrains.kotlin.types.TypeUtils
+
+internal class KtFe10CompileTimeConstantProvider(override val analysisSession: KtFe10AnalysisSession) : KtCompileTimeConstantProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun evaluate(expression: KtExpression): KtConstantValue? {
+        val resolveSession = analysisSession.resolveSession
+        val evaluator = ConstantExpressionEvaluator(
+            resolveSession.moduleDescriptor,
+            resolveSession.languageVersionSettings,
+            resolveSession.project
+        )
+
+        val bindingContext = analysisSession.analyze(expression)
+        val bindingTrace = DelegatingBindingTrace(bindingContext, "Binding trace for constant expression evaluation")
+        return evaluator.evaluateToConstantValue(expression, bindingTrace, TypeUtils.NO_EXPECTED_TYPE)?.toKtConstantValue()
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtCompletionCandidateChecker
+import org.jetbrains.kotlin.analysis.api.components.KtExtensionApplicabilityResult
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+
+internal class KtFe10CompletionCandidateChecker(override val analysisSession: KtFe10AnalysisSession) : KtCompletionCandidateChecker() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun checkExtensionFitsCandidate(
+        firSymbolForCandidate: KtCallableSymbol,
+        originalFile: KtFile,
+        nameExpression: KtSimpleNameExpression,
+        possibleExplicitReceiver: KtExpression?
+    ): KtExtensionApplicabilityResult = withValidityAssertion {
+        throw NotImplementedError("Method is not implemented for FE 1.0")
+    }
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.components.KtDiagnosticCheckerFilter
+import org.jetbrains.kotlin.analysis.api.components.KtDiagnosticProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.diagnostics.UnboundDiagnostic
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+import kotlin.reflect.KClass
+
+internal class KtFe10DiagnosticProvider(override val analysisSession: KtFe10AnalysisSession) : KtDiagnosticProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getDiagnosticsForElement(element: KtElement, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> {
+        withValidityAssertion {
+            val bindingContext = analysisSession.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 = analysisSession.analyze(ktFile)
+            val result = mutableListOf<KtDiagnosticWithPsi<*>>()
+            for (diagnostic in bindingContext.diagnostics) {
+                if (diagnostic.psiFile == ktFile) {
+                    result += KtFe10Diagnostic(diagnostic, token)
+                }
+            }
+            return result
+        }
+    }
+}
+
+private class KtFe10Diagnostic(private val diagnostic: Diagnostic, override val token: ValidityToken) : KtDiagnosticWithPsi<PsiElement> {
+    override val severity: Severity
+        get() = diagnostic.severity
+
+    override val factoryName: String
+        get() = diagnostic.factory.name
+
+    override val defaultMessage: String
+        get() {
+            @Suppress("UNCHECKED_CAST")
+            val factory = diagnostic.factory as DiagnosticFactory<UnboundDiagnostic>?
+            return factory?.defaultRenderer?.render(diagnostic) ?: ""
+        }
+
+    override val psi: PsiElement
+        get() = diagnostic.psiElement
+
+    override val textRanges: Collection<TextRange>
+        get() = diagnostic.textRanges
+
+    override val diagnosticClass: KClass<out KtDiagnosticWithPsi<PsiElement>>
+        get() = KtFe10Diagnostic::class
+}

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtExpressionInfoProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.cfg.WhenChecker
+import org.jetbrains.kotlin.diagnostics.WhenMissingCase
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtReturnExpression
+import org.jetbrains.kotlin.psi.KtWhenExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10ExpressionInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtExpressionInfoProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? = withValidityAssertion {
+        val bindingContext = analysisSession.analyze(returnExpression, AnalysisMode.PARTIAL)
+        val targetLabel = returnExpression.getTargetLabel() ?: return null
+        val labelTarget = bindingContext[BindingContext.LABEL_TARGET, targetLabel] as? KtDeclaration ?: return null
+        return with(analysisSession) { labelTarget.getSymbol() as? KtCallableSymbol }
+    }
+
+    override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> = withValidityAssertion {
+        val bindingContext = analysisSession.analyze(whenExpression)
+        return WhenChecker.getMissingCases(whenExpression, bindingContext)
+    }
+}

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

@@ -0,0 +1,231 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.components.KtExpressionTypeProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
+import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypes
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
+import org.jetbrains.kotlin.psi.psiUtil.unwrapParenthesesLabelsAndAnnotations
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
+import org.jetbrains.kotlin.resolve.calls.smartcasts.MultipleSmartCasts
+import org.jetbrains.kotlin.resolve.calls.util.getParameterForArgument
+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.ErrorUtils
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.isError
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
+
+class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisSession) : KtExpressionTypeProvider() {
+    private companion object {
+        val NON_EXPRESSION_CONTAINERS = arrayOf(
+            KtImportDirective::class.java,
+            KtTypeReference::class.java,
+            KtPackageDirective::class.java,
+            KtLabelReferenceExpression::class.java
+        )
+    }
+
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    private val builtIns: KotlinBuiltIns
+        get() = analysisSession.resolveSession.moduleDescriptor.builtIns
+
+    override fun getKtExpressionType(expression: KtExpression): KtType? = withValidityAssertion {
+        // 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) {
+            return null
+        }
+
+        val bindingContext = analysisSession.analyze(unwrapped, AnalysisMode.PARTIAL)
+        val kotlinType = expression.getType(bindingContext) ?: builtIns.unitType
+        return kotlinType.toKtType(analysisSession)
+    }
+
+    override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion {
+        // Handle callable declarations with explicit return type first
+        if (declaration is KtCallableDeclaration) {
+            val typeReference = declaration.typeReference
+
+            if (typeReference != null) {
+                val bindingContext = analysisSession.analyze(typeReference, AnalysisMode.PARTIAL)
+                val kotlinType = bindingContext[BindingContext.TYPE, typeReference]
+                    ?: ErrorUtils.createErrorType("Return type \"${typeReference.text}\" cannot be resolved")
+
+                return kotlinType.toKtType(analysisSession)
+            }
+        }
+
+        if (declaration is KtFunction && declaration !is KtConstructor<*> && declaration.equalsToken != null) {
+            val bindingContext = analysisSession.analyze(declaration)
+            val kotlinType = bindingContext[BindingContext.FUNCTION, declaration]?.returnType
+                ?: ErrorUtils.createErrorType("Implicit return type for function \"${declaration.name}\" cannot be resolved")
+
+            return kotlinType.toKtType(analysisSession)
+        }
+
+        if (declaration is KtProperty) {
+            val bindingContext = analysisSession.analyze(declaration)
+            val kotlinType = bindingContext[BindingContext.VARIABLE, declaration]?.returnType
+                ?: ErrorUtils.createErrorType("Implicit return type for property \"${declaration.name}\" cannot be resolved")
+
+            return kotlinType.toKtType(analysisSession)
+        }
+
+        if (declaration is KtPropertyAccessor) {
+            val bindingContext = analysisSession.analyze(declaration)
+            val kotlinType = bindingContext[BindingContext.PROPERTY_ACCESSOR, declaration]?.returnType
+                ?: ErrorUtils.createErrorType("Return type for property accessor \"${declaration.property.name}\" cannot be resolved")
+
+            return kotlinType.toKtType(analysisSession)
+        }
+
+        return builtIns.unitType.toKtType(analysisSession)
+    }
+
+    override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType = withValidityAssertion {
+        val analysisMode = if (declaration.hasDeclaredReturnType()) AnalysisMode.PARTIAL else AnalysisMode.FULL
+        val bindingContext = analysisSession.analyze(declaration, analysisMode)
+        val functionDescriptor = bindingContext[BindingContext.FUNCTION, declaration]
+
+        if (functionDescriptor != null) {
+            return getFunctionTypeForAbstractMethod(functionDescriptor, false).toKtType(analysisSession)
+        }
+
+        val parameterCount = declaration.valueParameters.size + (if (declaration.isExtensionDeclaration()) 1 else 0)
+
+        val function = when {
+            declaration.hasModifier(KtTokens.SUSPEND_KEYWORD) -> builtIns.getSuspendFunction(parameterCount)
+            else -> builtIns.getFunction(parameterCount)
+        }
+
+        val errorMessage = "Descriptor not found for function \"${declaration.name}\""
+        return ErrorUtils.createErrorTypeWithCustomConstructor(errorMessage, function.typeConstructor).toKtType(analysisSession)
+    }
+
+    override fun getExpectedType(expression: PsiElement): KtType? = withValidityAssertion {
+        val ktExpression = expression.getParentOfType<KtExpression>(false) ?: return null
+        val parentExpression = ktExpression.parent
+
+        // Unwrap specific expressions
+        when (ktExpression) {
+            is KtNameReferenceExpression -> {
+                if (parentExpression is KtDotQualifiedExpression && parentExpression.selectorExpression == ktExpression) {
+                    return getExpectedType(parentExpression)
+                }
+            }
+            is KtFunctionLiteral -> {
+                return getExpectedType(ktExpression.parent)
+            }
+        }
+
+        if (parentExpression is KtCallableDeclaration) {
+            if (expression is KtBlockExpression) {
+                return null
+            }
+
+            val bindingContext = analysisSession.analyze(parentExpression)
+            val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, parentExpression]
+            if (descriptor is CallableDescriptor) {
+                return descriptor.returnType?.takeIf { !it.isError }?.toKtType(analysisSession)
+            }
+        } else if (parentExpression is KtBinaryExpressionWithTypeRHS && KtPsiUtil.isCast(parentExpression)) {
+            val typeReference = parentExpression.right
+            if (typeReference != null) {
+                val bindingContext = analysisSession.analyze(typeReference)
+                var kotlinType = bindingContext[BindingContext.TYPE, typeReference]
+                if (kotlinType != null && KtPsiUtil.isSafeCast(parentExpression)) {
+                    kotlinType = kotlinType.makeNullable()
+                }
+                return kotlinType?.toKtType(analysisSession)
+            }
+        } else if (parentExpression is KtValueArgument) {
+            val callExpression = getContainingCallExpression(parentExpression)
+            if (callExpression != null) {
+                val bindingContext = analysisSession.analyze(callExpression)
+                val resolvedCall = callExpression.getResolvedCall(bindingContext)
+                if (resolvedCall != null) {
+                    val parameterDescriptor = resolvedCall.getParameterForArgument(parentExpression)?.original
+                    if (parameterDescriptor != null) {
+                        val kotlinType = when (val originalCallableDescriptor = parameterDescriptor.containingDeclaration) {
+                            is SamConstructorDescriptor -> originalCallableDescriptor.returnTypeOrNothing
+                            else -> parameterDescriptor.type
+                        }
+                        return kotlinType.takeIf { !it.isError }?.toKtType(analysisSession)
+                    }
+                }
+            }
+        }
+
+        val bindingContext = analysisSession.analyze(ktExpression)
+        val kotlinType = bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, ktExpression]
+        return kotlinType?.takeIf { !it.isError }?.toKtType(analysisSession)
+    }
+
+    private fun getContainingCallExpression(argument: KtValueArgument): KtCallExpression? {
+        return when (val parent = argument.parent) {
+            is KtCallExpression -> parent
+            is KtValueArgumentList -> parent.parent as? KtCallExpression
+            else -> null
+        }
+    }
+
+    override fun isDefinitelyNull(expression: KtExpression): Boolean = withValidityAssertion {
+        val unwrapped = expression.unwrapParenthesesLabelsAndAnnotations() as? KtElement ?: return false
+        val bindingContext = analysisSession.analyze(expression, AnalysisMode.PARTIAL)
+
+        if (bindingContext[BindingContext.SMARTCAST_NULL, expression] == true) {
+            return true
+        }
+
+        for (diagnostic in bindingContext.diagnostics.forElement(unwrapped)) {
+            if (diagnostic.factory == Errors.ALWAYS_NULL) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    override fun isDefinitelyNotNull(expression: KtExpression): Boolean = withValidityAssertion {
+        val ktExpression = expression as? KtExpression ?: return false
+        val bindingContext = analysisSession.analyze(ktExpression)
+
+        val smartCasts = bindingContext[BindingContext.SMARTCAST, ktExpression]
+
+        if (smartCasts is MultipleSmartCasts) {
+            if (smartCasts.map.values.all { !it.isMarkedNullable }) {
+                return true
+            }
+        }
+
+        val smartCastType = smartCasts?.defaultType
+        if (smartCastType != null && !smartCastType.isMarkedNullable) {
+            return true
+        }
+
+        val expressionType = expression.getType(bindingContext) ?: return false
+        return !TypeUtils.isNullableType(expressionType)
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizer
+import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtImportDirective
+
+internal class KtFe10ImportOptimizer(private val analysisSession: KtFe10AnalysisSession) : KtImportOptimizer() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun analyseImports(file: KtFile): KtImportOptimizerResult = withValidityAssertion {
+        val (allUnderImports, otherImports) = file.importDirectives.partition { it.isAllUnder }
+
+        val unusedImports = LinkedHashSet<KtImportDirective>()
+        val importedPackages = HashSet<FqName>()
+
+        for (import in allUnderImports) {
+            val fqName = import.importedFqName ?: continue
+            if (!importedPackages.add(fqName)) {
+                unusedImports += import
+            }
+        }
+
+        for (import in otherImports) {
+            val fqName = import.importedFqName ?: continue
+            if (import.alias == null && fqName.parent() in importedPackages) {
+                unusedImports += import
+            }
+        }
+
+        return KtImportOptimizerResult(unusedImports)
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtInheritorsProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtClassifierSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
+
+internal class KtFe10InheritorsProvider(override val analysisSession: KtFe10AnalysisSession) : KtInheritorsProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getInheritorsOfSealedClass(classSymbol: KtNamedClassOrObjectSymbol): List<KtNamedClassOrObjectSymbol> {
+        val classDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
+
+        val inheritorsProvider = analysisSession.resolveSession.sealedClassInheritorsProvider
+        val allowInDifferentFiles = analysisSession.resolveSession.languageVersionSettings
+            .supportsFeature(LanguageFeature.AllowSealedInheritorsInDifferentFilesOfSamePackage)
+
+        return inheritorsProvider.computeSealedSubclasses(classDescriptor, allowInDifferentFiles)
+            .mapNotNull { it.toKtClassifierSymbol(analysisSession) as? KtNamedClassOrObjectSymbol }
+    }
+
+    override fun getEnumEntries(classSymbol: KtNamedClassOrObjectSymbol): List<KtEnumEntrySymbol> = withValidityAssertion {
+        val enumDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
+        if (enumDescriptor.kind != ClassKind.ENUM_CLASS) {
+            return emptyList()
+        }
+
+        val result = mutableListOf<KtEnumEntrySymbol>()
+
+        for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) {
+            if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) {
+                result += KtFe10DescEnumEntrySymbol(entryDescriptor, analysisSession)
+            }
+        }
+
+        return result
+    }
+}

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtJvmTypeMapper
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10JvmTypeMapperContext
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
+import org.jetbrains.org.objectweb.asm.Type
+
+internal class KtFe10JvmTypeMapper(override val analysisSession: KtFe10AnalysisSession) : KtJvmTypeMapper() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisSession.resolveSession) }
+
+    override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type = withValidityAssertion {
+        val kotlinType = (type as KtFe10Type).type
+        return typeMapper.mapType(kotlinType, mode)
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtOverrideInfoProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+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.descriptors.symbols.descriptorBased.base.toKtClassifierSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
+import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.resolve.findOriginalTopMostOverriddenDescriptors
+import org.jetbrains.kotlin.util.ImplementationStatus
+
+internal class KtFe10OverrideInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtOverrideInfoProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun isVisible(memberSymbol: KtCallableSymbol, classSymbol: KtClassOrObjectSymbol): Boolean = withValidityAssertion {
+        val memberDescriptor = getSymbolDescriptor(memberSymbol) as? DeclarationDescriptorWithVisibility ?: return false
+        val classDescriptor = getSymbolDescriptor(classSymbol) ?: return false
+        return DescriptorVisibilities.isVisibleWithAnyReceiver(memberDescriptor, classDescriptor)
+    }
+
+    override fun getImplementationStatus(
+        memberSymbol: KtCallableSymbol,
+        parentClassSymbol: KtClassOrObjectSymbol
+    ): ImplementationStatus? = withValidityAssertion {
+        throw NotImplementedError("Method is not implemented for FE 1.0")
+    }
+
+    override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? = withValidityAssertion {
+        val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null
+        val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null
+        return originalCallableDescriptor.toKtCallableSymbol(analysisSession)
+    }
+
+    override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? = withValidityAssertion {
+        val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null
+        val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null
+        val containingClassDescriptor = originalCallableDescriptor.containingDeclaration as? ClassDescriptor ?: return null
+        return containingClassDescriptor.toKtClassifierSymbol(analysisSession) as? KtClassOrObjectSymbol
+    }
+}

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiType
+import com.intellij.psi.impl.cache.TypeInfo
+import com.intellij.psi.impl.compiled.ClsTypeElementImpl
+import com.intellij.psi.impl.compiled.SignatureParsing
+import com.intellij.psi.impl.compiled.StubBuildingVisitor
+import org.jetbrains.kotlin.analysis.api.components.KtPsiTypeProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10JvmTypeMapperContext
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
+import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
+import org.jetbrains.kotlin.name.SpecialNames
+import org.jetbrains.kotlin.types.*
+import java.text.StringCharacterIterator
+
+internal class KtFe10PsiTypeProvider(override val analysisSession: KtFe10AnalysisSession) : KtPsiTypeProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisSession.resolveSession) }
+
+    override fun asPsiType(type: KtType, context: PsiElement, mode: TypeMappingMode): PsiType? = withValidityAssertion {
+        val kotlinType = (type as KtFe10Type).type
+
+        if (kotlinType.isError || kotlinType.arguments.any { !it.isStarProjection && it.type.isError }) {
+            return null
+        }
+
+        return asPsiType(simplifyType(kotlinType), context, mode)
+    }
+
+    private fun simplifyType(type: UnwrappedType): KotlinType {
+        var result = type
+        do {
+            val oldResult = result
+            result = when (type) {
+                is FlexibleType -> type.upperBound
+                is DefinitelyNotNullType -> type.original
+                else -> type
+            }
+        } while (result !== oldResult)
+        return result
+    }
+
+    private fun asPsiType(type: KotlinType, context: PsiElement, mode: TypeMappingMode): PsiType? {
+        val signatureWriter = BothSignatureWriter(BothSignatureWriter.Mode.SKIP_CHECKS)
+        typeMapper.mapType(type, mode, signatureWriter)
+
+        val canonicalSignature = signatureWriter.toString()
+        require(!canonicalSignature.contains(SpecialNames.ANONYMOUS_STRING))
+
+        if (canonicalSignature.contains("L<error>")) {
+            return null
+        }
+
+        val signature = StringCharacterIterator(canonicalSignature)
+        val javaType = SignatureParsing.parseTypeString(signature, StubBuildingVisitor.GUESSING_MAPPER)
+        val typeInfo = TypeInfo.fromString(javaType, false)
+        val typeText = TypeInfo.createTypeText(typeInfo) ?: return null
+
+        val typeElement = ClsTypeElementImpl(context, typeText, '\u0000')
+        return typeElement.type
+    }
+}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import com.intellij.openapi.util.TextRange
+import org.jetbrains.kotlin.analysis.api.components.KtReferenceShortener
+import org.jetbrains.kotlin.analysis.api.components.ShortenCommand
+import org.jetbrains.kotlin.analysis.api.components.ShortenOption
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.psi.KtFile
+
+internal class KtFe10ReferenceShortener(override val analysisSession: KtFe10AnalysisSession) : KtReferenceShortener() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun collectShortenings(
+        file: KtFile,
+        selection: TextRange,
+        classShortenOption: (KtClassLikeSymbol) -> ShortenOption,
+        callableShortenOption: (KtCallableSymbol) -> ShortenOption
+    ): ShortenCommand {
+        // Compiler implementation does nothing.
+        // Descriptor-based shortening is implemented on the IDE plugin side.
+        return object : ShortenCommand {
+            override val isEmpty: Boolean
+                get() = true
+
+            override fun invokeShortening() {}
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtSamResolver
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescSamConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.load.java.sam.JvmSamConversionOracle
+import org.jetbrains.kotlin.resolve.sam.createSamConstructorFunction
+import org.jetbrains.kotlin.resolve.sam.getSingleAbstractMethodOrNull
+
+internal class KtFe10SamResolver(override val analysisSession: KtFe10AnalysisSession) : KtSamResolver() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getSamConstructor(ktClassLikeSymbol: KtClassLikeSymbol): KtSamConstructorSymbol? = withValidityAssertion {
+        val descriptor = getSymbolDescriptor(ktClassLikeSymbol)
+        if (descriptor is ClassDescriptor && getSingleAbstractMethodOrNull(descriptor) != null) {
+            val constructorDescriptor = createSamConstructorFunction(
+                descriptor.containingDeclaration,
+                descriptor,
+                analysisSession.resolveSession.samConversionResolver,
+                JvmSamConversionOracle(analysisSession.resolveSession.languageVersionSettings)
+            )
+
+            return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisSession)
+        }
+
+        return null
+    }
+}

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

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import com.intellij.openapi.diagnostic.Logger
+import org.jetbrains.kotlin.analysis.api.components.KtImplicitReceiver
+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.scopes.*
+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
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+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.SimpleKtCompositeScope
+import org.jetbrains.kotlin.analysis.api.scopes.*
+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.KtSymbolWithDeclarations
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.packageFragments
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.scopes.ChainedMemberScope
+import org.jetbrains.kotlin.resolve.scopes.LexicalScope
+import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy
+import org.jetbrains.kotlin.util.containingNonLocalDeclaration
+
+internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisSession) : KtScopeProvider() {
+    private companion object {
+        val LOG = Logger.getInstance(KtFe10ScopeProvider::class.java)
+    }
+
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtMemberScope = withValidityAssertion {
+        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
+            ?: return object : KtFe10EmptyScope(token), KtMemberScope {
+                override val owner get() = classSymbol
+            }
+
+        // TODO either this or declared scope should return a different set of members
+        return object : KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisSession), KtMemberScope {
+            override val owner get() = classSymbol
+        }
+    }
+
+    override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtDeclaredMemberScope = withValidityAssertion {
+        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
+            ?: return object : KtFe10EmptyScope(token), KtDeclaredMemberScope {
+                override val owner get() = classSymbol
+            }
+
+        return object : KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisSession), KtDeclaredMemberScope {
+            override val owner get() = classSymbol
+        }
+    }
+
+    override fun getStaticMemberScope(symbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
+        val descriptor = getDescriptor<ClassDescriptor>(symbol) ?: return KtFe10EmptyScope(token)
+        return KtFe10ScopeMember(descriptor.staticScope, analysisSession)
+    }
+
+    override fun getFileScope(fileSymbol: KtFileSymbol): KtDeclarationScope<KtSymbolWithDeclarations> = withValidityAssertion {
+        require(fileSymbol is KtFe10FileSymbol)
+        val scope = analysisSession.resolveSession.fileScopeProvider.getFileResolutionScope(fileSymbol.psi)
+
+        return object : KtFe10ScopeLexical(scope, analysisSession), KtDeclarationScope<KtSymbolWithDeclarations> {
+            override val owner: KtSymbolWithDeclarations
+                get() = withValidityAssertion { fileSymbol }
+        }
+    }
+
+    override fun getPackageScope(packageSymbol: KtPackageSymbol): KtPackageScope = withValidityAssertion {
+        require(packageSymbol is KtFe10PackageSymbol)
+        val packageFragments = analysisSession.resolveSession.packageFragmentProvider.packageFragments(packageSymbol.fqName)
+        val scopeDescription = "Compound scope for package \"${packageSymbol.fqName}\""
+        val chainedScope = ChainedMemberScope.create(scopeDescription, packageFragments.map { it.getMemberScope() })
+        return KtFe10PackageScope(chainedScope, packageSymbol, analysisSession)
+    }
+
+    override fun getCompositeScope(subScopes: List<KtScope>): KtCompositeScope = withValidityAssertion {
+        return SimpleKtCompositeScope(subScopes, token)
+    }
+
+    override fun getTypeScope(type: KtType): KtScope = withValidityAssertion {
+        require(type is KtFe10Type)
+        return KtFe10ScopeMember(type.type.memberScope, analysisSession)
+    }
+
+    override fun getScopeContextForPosition(originalFile: KtFile, positionInFakeFile: KtElement): KtScopeContext = withValidityAssertion {
+        val elementToAnalyze = positionInFakeFile.containingNonLocalDeclaration() ?: originalFile
+        val bindingContext = analysisSession.analyze(elementToAnalyze)
+
+        val lexicalScope = positionInFakeFile.getResolutionScope(bindingContext)
+        if (lexicalScope != null) {
+            val compositeScope = SimpleKtCompositeScope(listOf(KtFe10ScopeLexical(lexicalScope, analysisSession)), token)
+            return KtScopeContext(compositeScope, collectImplicitReceivers(lexicalScope))
+        }
+
+        val fileScope = analysisSession.resolveSession.fileScopeProvider.getFileResolutionScope(originalFile)
+        val compositeScope = SimpleKtCompositeScope(listOf(KtFe10ScopeLexical(fileScope, analysisSession)), token)
+        return KtScopeContext(compositeScope, collectImplicitReceivers(fileScope))
+    }
+
+    private inline fun <reified T : DeclarationDescriptor> getDescriptor(symbol: KtSymbol): T? {
+        return when (symbol) {
+            is KtFe10DescSymbol<*> -> symbol.descriptor as? T
+            is KtFe10PsiSymbol<*, *> -> symbol.descriptor as? T
+            else -> {
+                require(symbol is KtFe10Symbol) { "Unrecognized symbol implementation found" }
+                null
+            }
+        }
+    }
+
+    private fun collectImplicitReceivers(scope: LexicalScope): MutableList<KtImplicitReceiver> {
+        val result = mutableListOf<KtImplicitReceiver>()
+
+        for (implicitReceiver in scope.getImplicitReceiversHierarchy()) {
+            val type = implicitReceiver.type.toKtType(analysisSession)
+            val ownerDescriptor = implicitReceiver.containingDeclaration
+            val owner = ownerDescriptor.toKtSymbol(analysisSession)
+
+            if (owner == null) {
+                LOG.error("Unexpected implicit receiver owner: $ownerDescriptor (${ownerDescriptor.javaClass})")
+                continue
+            }
+
+            result += KtImplicitReceiver(token, type, owner)
+        }
+
+        return result
+    }
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.ImplicitReceiverSmartCast
+import org.jetbrains.kotlin.analysis.api.ImplicitReceiverSmartcastKind
+import org.jetbrains.kotlin.analysis.api.components.KtSmartCastProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.smartcasts.MultipleSmartCasts
+import org.jetbrains.kotlin.types.TypeIntersector
+
+internal class KtFe10SmartCastProvider(override val analysisSession: KtFe10AnalysisSession) : KtSmartCastProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getSmartCastedToType(expression: KtExpression): KtType? {
+        withValidityAssertion {
+            val bindingContext = analysisSession.analyze(expression)
+            val smartCasts = bindingContext[BindingContext.SMARTCAST, expression] ?: return null
+
+            if (smartCasts is MultipleSmartCasts) {
+                return TypeIntersector.intersectTypes(smartCasts.map.values)?.toKtType(analysisSession)
+            }
+
+            return smartCasts.defaultType?.toKtType(analysisSession)
+        }
+    }
+
+    override fun getImplicitReceiverSmartCast(expression: KtExpression): Collection<ImplicitReceiverSmartCast> {
+        withValidityAssertion {
+            val bindingContext = analysisSession.analyze(expression)
+            val smartCasts = bindingContext[BindingContext.IMPLICIT_RECEIVER_SMARTCAST, expression] ?: return emptyList()
+            return smartCasts.receiverTypes.map { (_, type) ->
+                val kind = ImplicitReceiverSmartcastKind.DISPATCH // TODO provide precise kind
+                ImplicitReceiverSmartCast(type.toKtType(analysisSession), kind)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtSubtypingComponent
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+
+internal class KtFe10SubtypingComponent(override val analysisSession: KtFe10AnalysisSession) : KtSubtypingComponent() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion {
+        require(first is KtFe10Type)
+        require(second is KtFe10Type)
+        return analysisSession.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.type, second.type)
+    }
+
+    override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean = withValidityAssertion {
+        require(subType is KtFe10Type)
+        require(superType is KtFe10Type)
+        val typeChecker = analysisSession.resolveSession.kotlinTypeCheckerOfOwnerModule
+        return typeChecker.isSubtypeOf(subType.type, superType.type)
+    }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtSymbolContainingDeclarationProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.cfg.getElementParentDeclaration
+
+internal class KtFe10SymbolContainingDeclarationProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSymbolContainingDeclarationProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getContainingDeclaration(symbol: KtSymbol): KtSymbolWithKind? {
+        if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) {
+            return null
+        }
+
+        return when (symbol) {
+            is KtPackageSymbol -> null
+            is KtBackingFieldSymbol -> symbol.owningProperty
+            is KtFe10DescSymbol<*> -> symbol.descriptor.containingDeclaration?.toKtSymbol(analysisSession) as? KtSymbolWithKind
+            is KtFe10PsiSymbol<*, *> -> {
+                val parentDeclaration = symbol.psi.getElementParentDeclaration()
+                if (parentDeclaration != null) {
+                    return with(analysisSession) {
+                        parentDeclaration.getSymbol() as? KtSymbolWithKind
+                    }
+                }
+
+                return null
+            }
+            else -> null
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtSymbolDeclarationOverridesProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+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.symbols.KtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
+import org.jetbrains.kotlin.resolve.descriptorUtil.isSubclassOf
+
+internal class KtFe10SymbolDeclarationOverridesProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSymbolDeclarationOverridesProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun <T : KtSymbol> getAllOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
+        val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList()
+        return getOverriddenDescriptors(descriptor, true).mapNotNull { it.toKtCallableSymbol(analysisSession) }
+    }
+
+    override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
+        val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList()
+        return getOverriddenDescriptors(descriptor, false).mapNotNull { it.toKtCallableSymbol(analysisSession) }
+    }
+
+    private fun getOverriddenDescriptors(
+        descriptor: CallableMemberDescriptor,
+        collectAllOverrides: Boolean
+    ): Collection<CallableMemberDescriptor> {
+        val overriddenDescriptors = LinkedHashSet<CallableMemberDescriptor>()
+        val queue = ArrayDeque<CallableMemberDescriptor>().apply { addAll(descriptor.overriddenDescriptors) }
+
+        while (queue.isNotEmpty()) {
+            val current = queue.removeFirst()
+
+            if (current.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+                overriddenDescriptors.add(current)
+
+                if (!collectAllOverrides) {
+                    continue
+                }
+            }
+
+            val overriddenDescriptorsForCurrent = current.overriddenDescriptors
+            for (overriddenDescriptor in overriddenDescriptorsForCurrent) {
+                if (overriddenDescriptor.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+                    overriddenDescriptors.add(overriddenDescriptor)
+                }
+            }
+            queue.addAll(overriddenDescriptorsForCurrent)
+        }
+
+        return overriddenDescriptors
+    }
+
+    override fun isSubClassOf(subClass: KtClassOrObjectSymbol, superClass: KtClassOrObjectSymbol): Boolean = withValidityAssertion {
+        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 {
+        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 {
+        throw NotImplementedError("Method is not implemented for FE 1.0")
+    }
+}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
+import org.jetbrains.kotlin.analysis.api.components.KtSymbolDeclarationRendererProvider
+import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.render
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+
+internal class KtFe10SymbolDeclarationRendererProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSymbolDeclarationRendererProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun render(symbol: KtSymbol, options: KtDeclarationRendererOptions): String {
+        val descriptor = getSymbolDescriptor(symbol)
+        if (descriptor != null) {
+            return descriptor.render(analysisSession, options)
+        }
+
+        // Rendering for unresolved symbols is not implemented
+        return ""
+    }
+
+    override fun render(type: KtType, options: KtTypeRendererOptions): String {
+        require(type is KtFe10Type)
+        val consumer = StringBuilder()
+        KtFe10TypeRenderer(options).render(type.type, consumer)
+        return consumer.toString()
+    }
+}

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtSymbolInfoProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.SpecialNames
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+
+internal class KtFe10SymbolInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtSymbolInfoProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun getDeprecation(symbol: KtSymbol): DeprecationInfo? {
+        val descriptor = getSymbolDescriptor(symbol) ?: return null
+        ForceResolveUtil.forceResolveAllContents(descriptor)
+        return analysisSession.deprecationResolver.getDeprecations(descriptor).firstOrNull()
+    }
+
+    override fun getDeprecation(symbol: KtSymbol, annotationUseSiteTarget: AnnotationUseSiteTarget?): DeprecationInfo? {
+        return getDeprecation(symbol) // TODO
+    }
+
+    override fun getGetterDeprecation(symbol: KtPropertySymbol): DeprecationInfo? {
+        val getter = symbol.getter ?: return null
+        val accessorDescriptor = getSymbolDescriptor(getter) as? PropertyAccessorDescriptor ?: return null
+        ForceResolveUtil.forceResolveAllContents(accessorDescriptor.correspondingProperty)
+        return analysisSession.deprecationResolver.getDeprecations(accessorDescriptor).firstOrNull()
+    }
+
+    override fun getSetterDeprecation(symbol: KtPropertySymbol): DeprecationInfo? {
+        val getter = symbol.setter ?: return null
+        val accessorDescriptor = getSymbolDescriptor(getter) as? PropertyAccessorDescriptor ?: return null
+        ForceResolveUtil.forceResolveAllContents(accessorDescriptor.correspondingProperty)
+        return analysisSession.deprecationResolver.getDeprecations(accessorDescriptor).firstOrNull()
+    }
+
+    override fun getJavaGetterName(symbol: KtPropertySymbol): Name {
+        val descriptor = getSymbolDescriptor(symbol) as? PropertyDescriptor
+        if (descriptor is SyntheticJavaPropertyDescriptor) {
+            return descriptor.getMethod.name
+        }
+
+        if (descriptor != null) {
+            val getter = descriptor.getter ?: return SpecialNames.NO_NAME_PROVIDED
+            return Name.identifier(DescriptorUtils.getJvmName(getter) ?: JvmAbi.getterName(descriptor.name.asString()))
+        }
+
+        val ktPropertyName = (symbol.psi as? KtProperty)?.name ?: return SpecialNames.NO_NAME_PROVIDED
+        return Name.identifier(JvmAbi.getterName(ktPropertyName))
+    }
+
+    override fun getJavaSetterName(symbol: KtPropertySymbol): Name? {
+        val descriptor = getSymbolDescriptor(symbol) as? PropertyDescriptor
+        if (descriptor is SyntheticJavaPropertyDescriptor) {
+            return descriptor.setMethod?.name
+        }
+
+        if (descriptor != null) {
+            if (!descriptor.isVar) {
+                return null
+            }
+
+            val setter = descriptor.setter ?: return SpecialNames.NO_NAME_PROVIDED
+            return Name.identifier(DescriptorUtils.getJvmName(setter) ?: JvmAbi.getterName(descriptor.name.asString()))
+        }
+
+        val ktPropertyName = (symbol.psi as? KtProperty)?.takeIf { it.isVar }?.name ?: return SpecialNames.NO_NAME_PROVIDED
+        return Name.identifier(JvmAbi.setterName(ktPropertyName))
+    }
+}

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

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10FileSymbol
+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.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
+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.resolve.scopes.DescriptorKindFilter
+
+internal class KtFe10SymbolProvider(override val analysisSession: KtFe10AnalysisSession) : KtSymbolProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol
+        get() = KtFe10PackageSymbol(FqName.ROOT, analysisSession)
+
+    override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion {
+        return KtFe10FileSymbol(psi, analysisSession)
+    }
+
+    override fun getParameterSymbol(psi: KtParameter): KtValueParameterSymbol = withValidityAssertion {
+        return KtFe10PsiValueParameterSymbol(psi, analysisSession)
+    }
+
+    override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
+        return if (psi.hasBody() && (psi.funKeyword == null || psi.nameIdentifier == null)) {
+            getAnonymousFunctionSymbol(psi)
+        } else {
+            KtFe10PsiFunctionSymbol(psi, analysisSession)
+        }
+    }
+
+    override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
+        return KtFe10PsiConstructorSymbol(psi, analysisSession)
+    }
+
+    override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
+        return KtFe10PsiTypeParameterSymbol(psi, analysisSession)
+    }
+
+    override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
+        return KtFe10PsiTypeAliasSymbol(psi, analysisSession)
+    }
+
+    override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
+        return KtFe10PsiEnumEntrySymbol(psi, analysisSession)
+    }
+
+    override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
+        return KtFe10PsiAnonymousFunctionSymbol(psi, analysisSession)
+    }
+
+    override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
+        return KtFe10PsiLiteralAnonymousFunctionSymbol(psi, analysisSession)
+    }
+
+    override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
+        return if (psi.isLocal) {
+            KtFe10PsiLocalVariableSymbol(psi, analysisSession)
+        } else {
+            KtFe10PsiKotlinPropertySymbol(psi, analysisSession)
+        }
+    }
+
+    override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
+        return KtFe10PsiAnonymousObjectSymbol(psi.objectDeclaration, analysisSession)
+    }
+
+    override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
+        return if (psi is KtObjectDeclaration && psi.isObjectLiteral()) {
+            KtFe10PsiAnonymousObjectSymbol(psi, analysisSession)
+        } else {
+            KtFe10PsiNamedClassOrObjectSymbol(psi, analysisSession)
+        }
+    }
+
+    override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? = withValidityAssertion {
+        if (psi is KtEnumEntry || psi.nameIdentifier == null) {
+            return null
+        }
+
+        return KtFe10PsiNamedClassOrObjectSymbol(psi, analysisSession)
+    }
+
+    override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
+        return if (psi.isGetter) {
+            KtFe10PsiPropertyGetterSymbol(psi, analysisSession)
+        } else {
+            KtFe10PsiPropertySetterSymbol(psi, analysisSession)
+        }
+    }
+
+    override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
+        return KtFe10PsiClassInitializerSymbol(psi, analysisSession)
+    }
+
+    override fun getClassOrObjectSymbolByClassId(classId: ClassId): KtClassOrObjectSymbol? = withValidityAssertion {
+        val descriptor = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
+        return descriptor.toKtClassSymbol(analysisSession)
+    }
+
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): Sequence<KtSymbol> = withValidityAssertion {
+        val packageViewDescriptor = analysisSession.resolveSession.moduleDescriptor.getPackage(packageFqName)
+        return packageViewDescriptor.memberScope.getContributedDescriptors(DescriptorKindFilter.ALL, nameFilter = { it == name })
+            .asSequence()
+            .filter { it.name == name }
+            .mapNotNull { it.toKtSymbol(analysisSession) as? KtCallableSymbol }
+    }
+}

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

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.KtStarProjectionTypeArgument
+import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
+import org.jetbrains.kotlin.analysis.api.components.KtClassTypeBuilder
+import org.jetbrains.kotlin.analysis.api.components.KtTypeCreator
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.descriptors.types.KtFe10ClassErrorType
+import org.jetbrains.kotlin.analysis.api.descriptors.types.KtFe10UsualClassType
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtClassType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+
+internal class KtFe10TypeCreator(override val analysisSession: KtFe10AnalysisSession) : KtTypeCreator() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType {
+        val descriptor: ClassDescriptor? = when (builder) {
+            is KtClassTypeBuilder.ByClassId -> {
+                val fqName = builder.classId.asSingleFqName()
+                analysisSession.resolveSession
+                    .getTopLevelClassifierDescriptors(fqName, NoLookupLocation.FROM_IDE)
+                    .firstIsInstanceOrNull()
+            }
+            is KtClassTypeBuilder.BySymbol -> {
+                getSymbolDescriptor(builder.symbol) as? ClassDescriptor
+            }
+        }
+
+        if (descriptor == null) {
+            val kotlinType = ErrorUtils.createErrorType("Cannot build class type, descriptor not found for builder $builder")
+            return KtFe10ClassErrorType(kotlinType as ErrorType, analysisSession)
+        }
+
+        val typeParameters = descriptor.typeConstructor.parameters
+        val type = if (typeParameters.size == builder.arguments.size) {
+            val projections = builder.arguments.mapIndexed { index, arg ->
+                when (arg) {
+                    is KtStarProjectionTypeArgument -> StarProjectionImpl(typeParameters[index])
+                    is KtTypeArgumentWithVariance -> TypeProjectionImpl(arg.variance, (arg.type as KtFe10Type).type)
+                }
+            }
+
+            TypeUtils.substituteProjectionsForParameters(descriptor, projections)
+        } else {
+            descriptor.defaultType
+        }
+
+        val typeWithNullability = TypeUtils.makeNullableAsSpecified(type, builder.nullability == KtTypeNullability.NULLABLE)
+        return KtFe10UsualClassType(typeWithNullability as SimpleType, descriptor, analysisSession)
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtTypeInfoProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils
+import org.jetbrains.kotlin.types.TypeUtils
+
+internal class KtFe10TypeInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtTypeInfoProvider() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun isFunctionalInterfaceType(type: KtType): Boolean = withValidityAssertion {
+        require(type is KtFe10Type)
+        return JavaSingleAbstractMethodUtils.isSamType(type.type)
+    }
+
+    override fun canBeNull(type: KtType): Boolean = withValidityAssertion {
+        require(type is KtFe10Type)
+        return TypeUtils.isNullableType(type.type)
+    }
+}

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

@@ -0,0 +1,451 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtBuiltinTypes
+import org.jetbrains.kotlin.analysis.api.components.KtTypeProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.isInterfaceLike
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+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.descriptors.utils.PublicApproximatorConfiguration
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.nameOrAnonymous
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.name.StandardClassIds
+import org.jetbrains.kotlin.psi.KtDoubleColonExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
+import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.NewCapturedType
+import org.jetbrains.kotlin.types.checker.NewTypeVariableConstructor
+import org.jetbrains.kotlin.types.typeUtil.isNothing
+import org.jetbrains.kotlin.types.typeUtil.supertypes
+import org.jetbrains.kotlin.util.containingNonLocalDeclaration
+
+internal class KtFe10TypeProvider(override val analysisSession: KtFe10AnalysisSession) : KtTypeProvider() {
+    @Suppress("SpellCheckingInspection")
+    private val typeApproximator by lazy {
+        TypeApproximator(
+            analysisSession.resolveSession.moduleDescriptor.builtIns,
+            analysisSession.resolveSession.languageVersionSettings
+        )
+    }
+
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override val builtinTypes: KtBuiltinTypes by cached { KtFe10BuiltinTypes(analysisSession) }
+
+    override fun approximateToSuperPublicDenotableType(type: KtType): KtType? = withValidityAssertion {
+        require(type is KtFe10Type)
+        return typeApproximator.approximateToSuperType(type.type, PublicApproximatorConfiguration)?.toKtType(analysisSession)
+    }
+
+    override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType = withValidityAssertion {
+        val kotlinType = (getSymbolDescriptor(symbol) as? ClassDescriptor)?.defaultType
+            ?: ErrorUtils.createErrorType("Cannot get class type for unresolved class ${symbol.nameOrAnonymous}")
+
+        return kotlinType.toKtType(analysisSession)
+    }
+
+    override fun commonSuperType(types: Collection<KtType>): KtType = withValidityAssertion {
+        val kotlinTypes = types.map { (it as KtFe10Type).type }
+        return CommonSupertypes.commonSupertype(kotlinTypes).toKtType(analysisSession)
+    }
+
+    override fun getKtType(ktTypeReference: KtTypeReference): KtType = withValidityAssertion {
+        val bindingContext = analysisSession.analyze(ktTypeReference, AnalysisMode.PARTIAL)
+        val kotlinType = bindingContext[BindingContext.TYPE, ktTypeReference]
+            ?: ErrorUtils.createErrorType("Cannot resolve type reference ${ktTypeReference.text}")
+        return kotlinType.toKtType(analysisSession)
+    }
+
+    override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? = withValidityAssertion {
+        val bindingContext = analysisSession.analyze(expression, AnalysisMode.PARTIAL)
+        val lhs = bindingContext[BindingContext.DOUBLE_COLON_LHS, expression] ?: return null
+        return lhs.type.toKtType(analysisSession)
+    }
+
+    override fun withNullability(type: KtType, newNullability: KtTypeNullability): KtType = withValidityAssertion {
+        require(type is KtFe10Type)
+        return type.type.makeNullableAsSpecified(newNullability == KtTypeNullability.NULLABLE).toKtType(analysisSession)
+    }
+
+    override fun haveCommonSubtype(a: KtType, b: KtType): Boolean {
+        return areTypesCompatible((a as KtFe10Type).type, (b as KtFe10Type).type)
+    }
+
+    override fun getImplicitReceiverTypesAtPosition(position: KtElement): List<KtType> {
+        val elementToAnalyze = position.containingNonLocalDeclaration() ?: position
+        val bindingContext = analysisSession.analyze(elementToAnalyze)
+
+        val lexicalScope = position.getResolutionScope(bindingContext) ?: return emptyList()
+        return lexicalScope.getImplicitReceiversHierarchy().map { it.type.toKtType(analysisSession) }
+    }
+
+    override fun getDirectSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
+        require(type is KtFe10Type)
+        return TypeUtils.getImmediateSupertypes(type.type).map { it.toKtType(analysisSession) }
+    }
+
+    override fun getAllSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
+        require(type is KtFe10Type)
+        return TypeUtils.getAllSupertypes(type.type).map { it.toKtType(analysisSession) }
+    }
+
+    private fun areTypesCompatible(a: KotlinType, b: KotlinType): Boolean {
+        if (a.isNothing() || b.isNothing() || TypeUtils.equalTypes(a, b) || (a.isNullable() && b.isNullable())) {
+            return true
+        }
+
+        val aConstructor = a.constructor
+        val bConstructor = b.constructor
+
+        if (aConstructor is IntersectionTypeConstructor) {
+            return aConstructor.supertypes.all { areTypesCompatible(it, b) }
+        }
+
+        if (bConstructor is IntersectionTypeConstructor) {
+            return bConstructor.supertypes.all { areTypesCompatible(a, it) }
+        }
+
+        val intersectionType = TypeIntersector.intersectTypes(listOf(a, b)) ?: return false
+        val intersectionTypeConstructor = intersectionType.constructor
+
+        if (intersectionTypeConstructor is IntersectionTypeConstructor) {
+            val intersectedTypes = intersectionTypeConstructor.supertypes
+            if (intersectedTypes.all { it.isNullable() }) {
+                return true
+            }
+
+            val collectedUpperBounds = intersectedTypes.flatMapTo(mutableSetOf()) { getUpperBounds(it) }
+            return areBoundsCompatible(collectedUpperBounds, emptySet())
+        } else {
+            return !intersectionType.isNothing()
+        }
+    }
+
+    private fun getUpperBounds(type: KotlinType): List<KotlinType> {
+        when (type) {
+            is FlexibleType -> return getUpperBounds(type.upperBound)
+            is DefinitelyNotNullType -> return getUpperBounds(type.original)
+            is ErrorType -> return emptyList()
+            is CapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
+            is NewCapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
+            is SimpleType -> {
+                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type)
+                if (typeParameterDescriptor != null) {
+                    return typeParameterDescriptor.upperBounds.flatMap { getUpperBounds(it) }
+                }
+
+                val typeConstructor = type.constructor
+                if (typeConstructor is NewTypeVariableConstructor) {
+                    return typeConstructor.originalTypeParameter?.upperBounds.orEmpty().flatMap { getUpperBounds(it) }
+                }
+                if (typeConstructor is IntersectionTypeConstructor) {
+                    return typeConstructor.supertypes.flatMap { getUpperBounds(it) }
+                }
+
+                return listOf(type)
+            }
+            else -> return emptyList()
+        }
+    }
+
+    private fun areBoundsCompatible(
+        upperBounds: Set<KotlinType>,
+        lowerBounds: Set<KotlinType>,
+        checkedTypeParameters: MutableSet<TypeParameterDescriptor> = mutableSetOf()
+    ): Boolean {
+        val upperBoundClasses = upperBounds.mapNotNull { getBoundClass(it) }.toSet()
+
+        val leafClassesOrInterfaces = computeLeafClassesOrInterfaces(upperBoundClasses)
+        if (areClassesOrInterfacesIncompatible(leafClassesOrInterfaces)) {
+            return false
+        }
+
+        if (!lowerBounds.all { lowerBoundType ->
+                val classesSatisfyingLowerBounds = collectSuperClasses(lowerBoundType)
+                leafClassesOrInterfaces.all { it in classesSatisfyingLowerBounds }
+            }
+        ) {
+            return false
+        }
+
+        if (upperBounds.size < 2) {
+            return true
+        }
+
+        val typeArgumentMapping = collectTypeArgumentMapping(upperBounds)
+        for ((typeParameter, boundTypeArguments) in typeArgumentMapping) {
+            if (!boundTypeArguments.isCompatible) {
+                return false
+            }
+
+            checkedTypeParameters.add(typeParameter)
+            if (!areBoundsCompatible(boundTypeArguments.upper, boundTypeArguments.lower, checkedTypeParameters)) {
+                return false
+            }
+        }
+
+        return true
+    }
+
+    private fun collectTypeArgumentMapping(upperBounds: Set<KotlinType>): Map<TypeParameterDescriptor, BoundTypeArguments> {
+        val typeArgumentMapping = LinkedHashMap<TypeParameterDescriptor, BoundTypeArguments>()
+        for (type in upperBounds) {
+            val mappingForType = type.toTypeArgumentMapping() ?: continue
+
+            val queue = ArrayDeque<TypeArgumentMapping>()
+            queue.addLast(mappingForType)
+
+            while (queue.isNotEmpty()) {
+                val (typeParameterOwner, mapping) = queue.removeFirst()
+                for (superType in typeParameterOwner.typeConstructor.supertypes) {
+                    val mappingForSupertype = superType.toTypeArgumentMapping(mapping) ?: continue
+                    queue.addLast(mappingForSupertype)
+                }
+
+                for ((typeParameterDescriptor, boundTypeArgument) in mapping) {
+                    val boundsForParameter = typeArgumentMapping.computeIfAbsent(typeParameterDescriptor) {
+                        var isCompatible = true
+                        val languageVersionSettings = analysisSession.resolveSession.languageVersionSettings
+                        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleEnums)) {
+                            isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.Enum
+                        }
+                        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleClasses)) {
+                            isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.KClass
+                        }
+
+                        BoundTypeArguments(mutableSetOf(), mutableSetOf(), isCompatible)
+                    }
+
+                    if (boundTypeArgument.variance.allowsOutPosition) {
+                        boundsForParameter.upper += boundTypeArgument.type.collectUpperBounds()
+                    }
+
+                    if (boundTypeArgument.variance.allowsInPosition) {
+                        boundsForParameter.lower += boundTypeArgument.type.collectLowerBounds()
+                    }
+                }
+            }
+
+        }
+        return typeArgumentMapping
+    }
+
+    private fun KotlinType.collectLowerBounds(): Set<KotlinType> {
+        when (this) {
+            is FlexibleType -> return lowerBound.collectLowerBounds()
+            is DefinitelyNotNullType -> return original.collectLowerBounds()
+            is ErrorType -> return emptySet()
+            is CapturedType, is NewCapturedType -> return constructor.supertypes.flatMapTo(mutableSetOf()) { it.collectLowerBounds() }
+            is SimpleType -> {
+                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(this)
+                if (typeParameterDescriptor != null) {
+                    return emptySet()
+                }
+
+                return when (val typeConstructor = this.constructor) {
+                    is NewTypeVariableConstructor -> emptySet()
+                    is IntersectionTypeConstructor -> typeConstructor.supertypes.flatMapTo(mutableSetOf()) { it.collectLowerBounds() }
+                    else -> setOf(this)
+                }
+
+            }
+            else -> return emptySet()
+        }
+    }
+
+    private fun KotlinType.collectUpperBounds(): Set<KotlinType> {
+        when (this) {
+            is FlexibleType -> return lowerBound.collectUpperBounds()
+            is DefinitelyNotNullType -> return original.collectUpperBounds()
+            is ErrorType -> return emptySet()
+            is CapturedType, is NewCapturedType -> return constructor.supertypes.flatMapTo(mutableSetOf()) { it.collectUpperBounds() }
+            is SimpleType -> {
+                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(this)
+                if (typeParameterDescriptor != null) {
+                    return typeParameterDescriptor.upperBounds.flatMapTo(mutableSetOf()) { it.collectUpperBounds() }
+                }
+
+                return when (val typeConstructor = this.constructor) {
+                    is NewTypeVariableConstructor -> typeConstructor.supertypes.flatMapTo(mutableSetOf()) { it.collectUpperBounds() }
+                    is IntersectionTypeConstructor -> typeConstructor.supertypes.flatMapTo(mutableSetOf()) { it.collectUpperBounds() }
+                    else -> setOf(this)
+                }
+
+            }
+            else -> return emptySet()
+        }
+    }
+
+    private fun KotlinType.toTypeArgumentMapping(
+        envMapping: Map<TypeParameterDescriptor, BoundTypeArgument> = emptyMap()
+    ): TypeArgumentMapping? {
+        val typeParameterOwner = constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters ?: return null
+
+        val mapping = mutableMapOf<TypeParameterDescriptor, BoundTypeArgument>()
+        arguments.forEachIndexed { index, typeProjection ->
+            val typeParameter = typeParameterOwner.declaredTypeParameters.getOrNull(index) ?: return@forEachIndexed
+            var boundTypeArgument: BoundTypeArgument = when {
+                typeProjection.isStarProjection -> return@forEachIndexed
+                typeProjection.projectionKind == Variance.INVARIANT -> {
+                    when (typeParameter.variance) {
+                        Variance.IN_VARIANCE -> BoundTypeArgument(typeProjection.type, Variance.IN_VARIANCE)
+                        Variance.OUT_VARIANCE -> BoundTypeArgument(typeProjection.type, Variance.OUT_VARIANCE)
+                        else -> BoundTypeArgument(typeProjection.type, Variance.INVARIANT)
+                    }
+                }
+                else -> BoundTypeArgument(typeProjection.type, typeProjection.projectionKind)
+            }
+
+            val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(boundTypeArgument.type)
+            if (typeParameterDescriptor != null) {
+                val mappedTypeArgument = envMapping[typeParameterDescriptor]
+                if (mappedTypeArgument != null) {
+                    boundTypeArgument = mappedTypeArgument
+                }
+            }
+
+            mapping.put(typeParameter, boundTypeArgument)
+        }
+
+        return TypeArgumentMapping(typeParameterOwner, mapping)
+    }
+
+    private data class TypeArgumentMapping(
+        val owner: ClassifierDescriptorWithTypeParameters,
+        val mapping: Map<TypeParameterDescriptor, BoundTypeArgument>
+    )
+
+    private data class BoundTypeArgument(val type: KotlinType, val variance: Variance)
+    private data class BoundTypeArguments(val upper: MutableSet<KotlinType>, val lower: MutableSet<KotlinType>, val isCompatible: Boolean)
+
+    private fun computeLeafClassesOrInterfaces(upperBoundClasses: Set<ClassDescriptor>): Set<ClassDescriptor> {
+        val isLeaf = mutableMapOf<ClassDescriptor, Boolean>()
+        upperBoundClasses.associateWithTo(isLeaf) { true }
+        val queue = ArrayDeque(upperBoundClasses)
+        while (queue.isNotEmpty()) {
+            for (superClass in DescriptorUtils.getSuperclassDescriptors(queue.removeFirst())) {
+                when (isLeaf[superClass]) {
+                    true -> isLeaf[superClass] = false
+                    false -> {}
+                    else -> {
+                        isLeaf[superClass] = false
+                        queue.addLast(superClass)
+                    }
+                }
+            }
+        }
+
+        return isLeaf.filterValues { it }.keys
+    }
+
+    private fun getBoundClass(type: KotlinType): ClassDescriptor? {
+        return when (val declaration = type.constructor.declarationDescriptor) {
+            is ClassDescriptor -> declaration
+            is TypeAliasDescriptor -> getBoundClass(declaration.expandedType)
+            else -> null
+        }
+    }
+
+    private fun collectSuperClasses(type: KotlinType): Set<ClassDescriptor> {
+        val initialClass = getBoundClass(type) ?: return emptySet()
+
+        val result = mutableSetOf<ClassDescriptor>()
+        result.add(initialClass)
+
+        val queue = ArrayDeque<ClassDescriptor>()
+        queue.addLast(initialClass)
+        while (queue.isNotEmpty()) {
+            val current = queue.removeFirst()
+            val supertypes = DescriptorUtils.getSuperclassDescriptors(current)
+            supertypes.filterNotTo(queue) { it !in result }
+            result.addAll(supertypes)
+        }
+
+        return result
+    }
+
+    private fun areClassesOrInterfacesIncompatible(classesOrInterfaces: Collection<ClassDescriptor>): Boolean {
+        val classes = classesOrInterfaces.filter { !it.isInterfaceLike }
+        return when {
+            classes.size >= 2 -> true
+            !classes.any { it.isFinalOrEnum } -> false
+            classesOrInterfaces.size > classes.size -> true
+            else -> false
+        }
+    }
+}
+
+private class KtFe10BuiltinTypes(private val analysisSession: KtFe10AnalysisSession) : KtBuiltinTypes() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    private val builtIns = analysisSession.resolveSession.moduleDescriptor.builtIns
+
+    override val INT: KtType
+        get() = withValidityAssertion { builtIns.intType.toKtType(analysisSession) }
+
+    override val LONG: KtType
+        get() = withValidityAssertion { builtIns.longType.toKtType(analysisSession) }
+
+    override val SHORT: KtType
+        get() = withValidityAssertion { builtIns.shortType.toKtType(analysisSession) }
+
+    override val BYTE: KtType
+        get() = withValidityAssertion { builtIns.byteType.toKtType(analysisSession) }
+
+    override val FLOAT: KtType
+        get() = withValidityAssertion { builtIns.floatType.toKtType(analysisSession) }
+
+    override val DOUBLE: KtType
+        get() = withValidityAssertion { builtIns.doubleType.toKtType(analysisSession) }
+
+    override val BOOLEAN: KtType
+        get() = withValidityAssertion { builtIns.booleanType.toKtType(analysisSession) }
+
+    override val CHAR: KtType
+        get() = withValidityAssertion { builtIns.charType.toKtType(analysisSession) }
+
+    override val STRING: KtType
+        get() = withValidityAssertion { builtIns.stringType.toKtType(analysisSession) }
+
+    override val UNIT: KtType
+        get() = withValidityAssertion { builtIns.unitType.toKtType(analysisSession) }
+
+    override val NOTHING: KtType
+        get() = withValidityAssertion { builtIns.nothingType.toKtType(analysisSession) }
+
+    override val ANY: KtType
+        get() = withValidityAssertion { builtIns.anyType.toKtType(analysisSession) }
+
+    override val THROWABLE: KtType
+        get() = withValidityAssertion { builtIns.throwable.defaultType.toKtType(analysisSession) }
+
+    override val NULLABLE_ANY: KtType
+        get() = withValidityAssertion { builtIns.nullableAnyType.toKtType(analysisSession) }
+
+    override val NULLABLE_NOTHING: KtType
+        get() = withValidityAssertion { builtIns.nullableNothingType.toKtType(analysisSession) }
+
+}

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.components.KtVisibilityChecker
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession.AnalysisMode
+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.symbols.KtFileSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
+import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy
+
+internal class KtFe10VisibilityChecker(override val analysisSession: KtFe10AnalysisSession) : KtVisibilityChecker() {
+    override val token: ValidityToken
+        get() = analysisSession.token
+
+    override fun isVisible(
+        candidateSymbol: KtSymbolWithVisibility,
+        useSiteFile: KtFileSymbol,
+        position: PsiElement,
+        receiverExpression: KtExpression?
+    ): Boolean = withValidityAssertion {
+        if (candidateSymbol.visibility == Visibilities.Public) {
+            return true
+        }
+
+        val targetDescriptor = getSymbolDescriptor(candidateSymbol) as? DeclarationDescriptorWithVisibility ?: return false
+
+        val useSiteDeclaration = findContainingNonLocalDeclaration(position) ?: return false
+        val bindingContextForUseSite = analysisSession.analyze(useSiteDeclaration)
+        val useSiteDescriptor = bindingContextForUseSite[BindingContext.DECLARATION_TO_DESCRIPTOR, useSiteDeclaration] ?: return false
+
+        if (receiverExpression != null && !targetDescriptor.isExtension) {
+            val bindingContext = analysisSession.analyze(receiverExpression, AnalysisMode.PARTIAL)
+            val receiverType = bindingContext.getType(receiverExpression) ?: return false
+            val explicitReceiver = ExpressionReceiver.create(receiverExpression, receiverType, bindingContext)
+            return DescriptorVisibilities.isVisible(explicitReceiver, targetDescriptor, useSiteDescriptor)
+        } else {
+            val bindingContext = analysisSession.analyze(useSiteDeclaration, AnalysisMode.FULL)
+
+            val lexicalScope = position.getResolutionScope(bindingContext)
+            if (lexicalScope != null) {
+                return lexicalScope.getImplicitReceiversHierarchy()
+                    .any { DescriptorVisibilities.isVisible(it.value, targetDescriptor, useSiteDescriptor) }
+            }
+        }
+
+        return false
+    }
+}
+
+private fun findContainingNonLocalDeclaration(element: PsiElement): KtCallableDeclaration? {
+    for (parent in element.parentsWithSelf) {
+        if (parent is KtCallableDeclaration && !KtPsiUtil.isLocal(parent)) {
+            return parent
+        }
+    }
+
+    return null
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtArrayAccessReference
+import org.jetbrains.kotlin.psi.KtArrayAccessExpression
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+
+internal class KtFe10ArrayAccessReference(expression: KtArrayAccessExpression) : KtArrayAccessReference(expression), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        require(this is KtFe10AnalysisSession)
+
+        val bindingContext = analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor
+        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+    }
+
+    override fun handleElementRename(newElementName: String): PsiElement? {
+        TODO("Not yet implemented")
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtCollectionLiteralReference
+import org.jetbrains.kotlin.psi.KtCollectionLiteralExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10CollectionLiteralReference(
+    expression: KtCollectionLiteralExpression
+) : KtCollectionLiteralReference(expression), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        require(this is KtFe10AnalysisSession)
+
+        val bindingContext = analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        val descriptor = bindingContext[BindingContext.COLLECTION_LITERAL_CALL, expression]?.resultingDescriptor
+        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtConstructorDelegationReference
+import org.jetbrains.kotlin.psi.KtConstructorDelegationReferenceExpression
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+
+internal class KtFe10ConstructorDelegationReference(
+    expression: KtConstructorDelegationReferenceExpression
+) : KtConstructorDelegationReference(expression), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        require(this is KtFe10AnalysisSession)
+
+        val bindingContext = analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor
+        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtDestructuringDeclarationReference
+import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10DestructuringDeclarationEntry(
+    element: KtDestructuringDeclarationEntry
+) : KtDestructuringDeclarationReference(element), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        check(this is KtFe10AnalysisSession)
+
+        val bindingContext = analyze(element, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        val descriptor = bindingContext[BindingContext.COMPONENT_RESOLVED_CALL, element]?.resultingDescriptor
+        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+    }
+
+    override fun canRename(): Boolean {
+        return false // TODO
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtForLoopInReference
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10ForLoopInReference(element: KtForExpression) : KtForLoopInReference(element), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        check(this is KtFe10AnalysisSession)
+
+        val loopRange = element.loopRange ?: return emptyList()
+        val bindingContext = analyze(loopRange)
+
+        return listOf(
+            BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL,
+            BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL,
+            BindingContext.LOOP_RANGE_NEXT_RESOLVED_CALL
+        ).mapNotNull { slice -> bindingContext[slice, loopRange]?.resultingDescriptor?.toKtCallableSymbol(this) }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtInvokeFunctionReference
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+
+internal class KtFe10InvokeFunctionReference(expression: KtCallExpression) : KtInvokeFunctionReference(expression), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        require(this is KtFe10AnalysisSession)
+
+        val bindingContext = analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor
+        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+    }
+
+    override fun doRenameImplicitConventionalCall(newName: String?): KtExpression {
+        TODO("Not yet implemented")
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.idea.references.KtPropertyDelegationMethodsReference
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPropertyDelegate
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PropertyDelegationMethodsReference(
+    element: KtPropertyDelegate
+) : KtPropertyDelegationMethodsReference(element), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        require(this is KtFe10AnalysisSession)
+
+        val property = expression.parent as? KtProperty
+        if (property == null || property.delegate !== element) {
+            return emptyList()
+        }
+
+        val bindingContext = analyze(property)
+        val propertyDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, property]
+
+        if (propertyDescriptor is PropertyDescriptor) {
+            return listOfNotNull(propertyDescriptor.getter, propertyDescriptor.setter)
+                .mapNotNull { accessor ->
+                    val descriptor = bindingContext[BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, accessor]?.resultingDescriptor
+                    descriptor?.toKtCallableSymbol(this)
+                }
+        }
+
+        return emptyList()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10Reference
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtImportAlias
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+
+internal class KtFe10SimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleNameReference(expression), KtFe10Reference {
+    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
+        require(this is KtFe10AnalysisSession)
+
+        val bindingContext = analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+
+        val descriptor = bindingContext[BindingContext.REFERENCE_TARGET, expression]
+            ?: expression.getResolvedCall(bindingContext)?.resultingDescriptor
+
+        return listOfNotNull(descriptor?.toKtSymbol(this))
+    }
+
+    override fun doCanBeReferenceTo(candidateTarget: PsiElement): Boolean {
+        return true // TODO
+    }
+
+    override fun isReferenceTo(element: PsiElement): Boolean {
+        return resolve() == element // TODO
+    }
+
+    override fun handleElementRename(newElementName: String): PsiElement? {
+        TODO("Not yet implemented")
+    }
+
+    override fun bindToElement(element: PsiElement, shorteningMode: ShorteningMode): PsiElement {
+        TODO("Not yet implemented")
+    }
+
+    override fun bindToFqName(fqName: FqName, shorteningMode: ShorteningMode, targetElement: PsiElement?): PsiElement {
+        TODO("Not yet implemented")
+    }
+
+    override fun getImportAlias(): KtImportAlias? {
+        TODO("Not yet implemented")
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10KotlinReferenceProviderContributor.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references.base
+
+import org.jetbrains.kotlin.analysis.api.descriptors.references.*
+import org.jetbrains.kotlin.idea.references.KotlinPsiReferenceRegistrar
+import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
+
+class KtFe10KotlinReferenceProviderContributor : KotlinReferenceProviderContributor {
+    override fun registerReferenceProviders(registrar: KotlinPsiReferenceRegistrar) {
+        with(registrar) {
+            registerProvider(factory = ::KtFe10SimpleNameReference)
+            registerProvider(factory = ::KtFe10ForLoopInReference)
+            registerProvider(factory = ::KtFe10InvokeFunctionReference)
+            registerProvider(factory = ::KtFe10PropertyDelegationMethodsReference)
+            registerProvider(factory = ::KtFe10DestructuringDeclarationEntry)
+            registerProvider(factory = ::KtFe10ArrayAccessReference)
+            registerProvider(factory = ::KtFe10ConstructorDelegationReference)
+            registerProvider(factory = ::KtFe10CollectionLiteralReference)
+        }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references.base
+
+import com.intellij.psi.PsiElementResolveResult
+import com.intellij.psi.ResolveResult
+import com.intellij.psi.impl.source.resolve.ResolveCache
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.impl.base.util.runInPossiblyEdtThread
+import org.jetbrains.kotlin.analysis.api.tokens.HackToForceAllowRunningAnalyzeOnEDT
+import org.jetbrains.kotlin.idea.references.AbstractKtReference
+import org.jetbrains.kotlin.idea.references.KtReference
+import org.jetbrains.kotlin.load.kotlin.toSourceElement
+import org.jetbrains.kotlin.psi.KtReferenceExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+import org.jetbrains.kotlin.resolve.source.getPsi
+
+object KtFe10PolyVariantResolver : ResolveCache.PolyVariantResolver<KtReference> {
+    @OptIn(HackToForceAllowRunningAnalyzeOnEDT::class)
+    override fun resolve(reference: KtReference, incompleteCode: Boolean): Array<ResolveResult> {
+        require(reference is AbstractKtReference<*>) { "reference should be AbstractKtReference, but was ${reference::class}" }
+        return runInPossiblyEdtThread {
+            val expression = reference.expression
+            analyse(reference.expression) {
+                val session = this as KtFe10AnalysisSession
+                val bindingContext = session.analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+                val descriptor = when (expression) {
+                    is KtReferenceExpression -> bindingContext[BindingContext.REFERENCE_TARGET, expression]
+                    else -> expression.getResolvedCall(bindingContext)?.resultingDescriptor
+                }
+                val source = descriptor?.toSourceElement?.getPsi()
+                if (source != null) arrayOf(PsiElementResolveResult(source)) else emptyArray()
+            }
+        }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10Reference.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.references.base
+
+import com.intellij.psi.impl.source.resolve.ResolveCache
+import org.jetbrains.kotlin.analysis.api.KtSymbolBasedReference
+import org.jetbrains.kotlin.idea.references.KtReference
+
+interface KtFe10Reference : KtReference, KtSymbolBasedReference {
+    override val resolver: ResolveCache.PolyVariantResolver<KtReference>
+        get() = KtFe10PolyVariantResolver
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10EmptyScope.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.scopes
+
+import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+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.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.name.Name
+
+internal open class KtFe10EmptyScope(override val token: ValidityToken) : KtScope, ValidityTokenOwner {
+    override fun getAllPossibleNames(): Set<Name> = withValidityAssertion {
+        return emptySet()
+    }
+
+    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
+        return emptySet()
+    }
+
+    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
+        return emptySet()
+    }
+
+    override fun getAllSymbols(): Sequence<KtSymbol> = withValidityAssertion {
+        return emptySequence()
+    }
+
+    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
+        return emptySequence()
+    }
+
+    override fun getClassifierSymbols(nameFilter: KtScopeNameFilter): Sequence<KtClassifierSymbol> = withValidityAssertion {
+        return emptySequence()
+    }
+
+    override fun getConstructors(): Sequence<KtConstructorSymbol> = withValidityAssertion {
+        return emptySequence()
+    }
+
+    override fun mayContainName(name: Name): Boolean = withValidityAssertion {
+        return false
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.scopes
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
+import org.jetbrains.kotlin.analysis.api.scopes.KtPackageScope
+import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
+import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+
+internal class KtFe10PackageScope(
+    scope: MemberScope,
+    private val owner: KtPackageSymbol,
+    analysisSession: KtFe10AnalysisSession
+) : KtFe10ScopeMember(scope, analysisSession), KtPackageScope {
+    override val fqName: FqName
+        get() = withValidityAssertion { owner.fqName }
+
+    override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {
+        val packageFragmentProvider = analysisSession.resolveSession.packageFragmentProvider
+        return packageFragmentProvider.getSubPackagesOf(owner.fqName, nameFilter)
+            .asSequence()
+            .map { KtFe10PackageSymbol(it, analysisSession) }
+    }
+
+    override fun getConstructors(): Sequence<KtConstructorSymbol> = withValidityAssertion {
+        return emptySequence()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.scopes
+
+import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
+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.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.LexicalScope
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.resolve.scopes.ResolutionScope
+
+internal abstract class KtFe10ScopeResolution : KtScope, ValidityTokenOwner {
+    abstract val analysisSession: KtFe10AnalysisSession
+    abstract val scope: ResolutionScope
+
+    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
+        return scope
+            .getContributedDescriptors(kindFilter = DescriptorKindFilter.ALL, nameFilter)
+            .asSequence()
+            .filter { nameFilter(it.name) }
+            .mapNotNull { it.toKtSymbol(analysisSession) as? KtCallableSymbol }
+    }
+
+    override fun getClassifierSymbols(nameFilter: KtScopeNameFilter): Sequence<KtClassifierSymbol> = withValidityAssertion {
+        return scope
+            .getContributedDescriptors(kindFilter = DescriptorKindFilter.CLASSIFIERS, nameFilter)
+            .asSequence()
+            .filter { nameFilter(it.name) }
+            .mapNotNull { it.toKtSymbol(analysisSession) as? KtClassifierSymbol }
+    }
+
+    override fun getConstructors(): Sequence<KtConstructorSymbol> = withValidityAssertion {
+        return scope
+            .getContributedDescriptors(kindFilter = DescriptorKindFilter.FUNCTIONS)
+            .asSequence()
+            .filterIsInstance<ConstructorDescriptor>()
+            .map { it.toKtConstructorSymbol(analysisSession) }
+    }
+
+    override val token: ValidityToken
+        get() = analysisSession.token
+}
+
+internal open class KtFe10ScopeLexical(
+    override val scope: LexicalScope,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFe10ScopeResolution(), ValidityTokenOwner {
+    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
+        return emptySet()
+    }
+
+    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
+        return emptySet()
+    }
+}
+
+internal open class KtFe10ScopeMember(
+    override val scope: MemberScope,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFe10ScopeResolution(), ValidityTokenOwner {
+    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
+        return scope.getFunctionNames() + scope.getVariableNames()
+    }
+
+    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
+        return scope.getClassifierNames() ?: emptySet()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10AnnotatedSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithDeclarations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.psi.KtFile
+
+internal class KtFe10FileSymbol(
+    private val file: KtFile,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFileSymbol(), KtSymbolWithDeclarations, KtFe10AnnotatedSymbol {
+    override val psi: KtFile
+        get() = withValidityAssertion { file }
+
+    override val annotationsObject: Annotations
+        get() = analysisSession.resolveSession.getFileAnnotations(file)
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion { if (file.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }
+
+    override fun createPointer(): KtSymbolPointer<KtFileSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols
+
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiUtilCore
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10PackageSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.name.FqName
+
+internal class KtFe10PackageSymbol(
+    private val packageName: FqName,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtPackageSymbol(), KtFe10Symbol {
+    override val fqName: FqName
+        get() = withValidityAssertion { packageName }
+
+    override val psi: PsiElement? by cached {
+        val project = analysisSession.resolveSession.project
+        JavaPsiFacade.getInstance(project).findPackage(fqName.asString())
+    }
+
+    override fun createPointer(): KtSymbolPointer<KtPackageSymbol> = withValidityAssertion {
+        return KtFe10PackageSymbolPointer(fqName)
+    }
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion {
+            val virtualFile = PsiUtilCore.getVirtualFile(psi)
+            return if (virtualFile != null) {
+                analysisSession.getOrigin(virtualFile)
+            } else {
+                KtSymbolOrigin.LIBRARY
+            }
+        }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10AnnotatedSymbol.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.base
+
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescAnnotationCall
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotatedSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
+
+internal interface KtFe10AnnotatedSymbol : KtAnnotatedSymbol, KtFe10Symbol {
+    val annotationsObject: Annotations
+
+    override val annotations: List<KtAnnotationCall>
+        get() = withValidityAssertion {
+            annotationsObject.map { KtFe10DescAnnotationCall(it, token) }
+        }
+
+    override val annotationClassIds: Collection<ClassId>
+        get() {
+            withValidityAssertion {
+                val result = mutableListOf<ClassId>()
+                for (annotation in annotationsObject) {
+                    val annotationClass = annotation.annotationClass ?: continue
+                    result += annotationClass.maybeLocalClassId
+                }
+                return result
+            }
+        }
+
+    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
+        return annotationsObject.hasAnnotation(classId.asSingleFqName())
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.base
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+
+interface KtFe10Symbol : KtSymbol {
+    val analysisSession: KtFe10AnalysisSession
+
+    override val token: ValidityToken
+        get() = analysisSession.token
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnnotationCall.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.SourceElement
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtCallElement
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
+import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor
+import org.jetbrains.kotlin.resolve.source.PsiSourceElement
+
+internal class KtFe10DescAnnotationCall(
+    private val descriptor: AnnotationDescriptor,
+    override val token: ValidityToken
+) : KtAnnotationCall() {
+    override val classId: ClassId?
+        get() = withValidityAssertion { descriptor.annotationClass?.maybeLocalClassId }
+
+    override val useSiteTarget: AnnotationUseSiteTarget?
+        get() = withValidityAssertion {
+            val psiTarget = (descriptor as? LazyAnnotationDescriptor)?.annotationEntry?.useSiteTarget ?: return null
+            return psiTarget.getAnnotationUseSiteTarget()
+        }
+
+    val source: SourceElement
+        get() = withValidityAssertion { descriptor.source }
+
+    override val psi: KtCallElement?
+        get() = withValidityAssertion { (source as? PsiSourceElement)?.psi as? KtAnnotationEntry }
+
+    override val arguments: List<KtNamedConstantValue>
+        get() = withValidityAssertion {
+            descriptor.allValueArguments.map { (name, value) -> KtNamedConstantValue(name.asString(), value.toKtConstantValue()) }
+        }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktHasStableParameterNames
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+
+internal class KtFe10DescAnonymousFunctionSymbol(
+    override val descriptor: FunctionDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtAnonymousFunctionSymbol(), KtFe10DescMemberSymbol<FunctionDescriptor> {
+    override val isExtension: Boolean
+        get() = withValidityAssertion { descriptor.isExtension }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+
+internal class KtFe10DescAnonymousObjectSymbol(
+    override val descriptor: ClassDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtAnonymousObjectSymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
+    override val superTypes: List<KtTypeAndAnnotations>
+        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtTypeAndAnnotations(analysisSession) } }
+
+    override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescFunctionLikeSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.name.ClassId
+
+internal class KtFe10DescConstructorSymbol(
+    override val descriptor: ConstructorDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtConstructorSymbol(), KtFe10DescMemberSymbol<ConstructorDescriptor> {
+    override val isPrimary: Boolean
+        get() = withValidityAssertion { descriptor.isPrimary }
+
+    override val containingClassIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { descriptor.constructedClass.classId }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisSession) }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion {
+            val containingClass = descriptor.constructedClass.containingDeclaration as? ClassDescriptor ?: return null
+            return containingClass.defaultType.toKtType(analysisSession)
+        }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+
+    override fun createPointer(): KtSymbolPointer<KtConstructorSymbol> = withValidityAssertion {
+        val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
+        if (pointerByPsi != null) {
+            return pointerByPsi
+        }
+
+        val callableId = descriptor.callableId
+        if (callableId != null && !callableId.isLocal) {
+            val signature = descriptor.getSymbolPointerSignature(analysisSession)
+            return KtFe10DescFunctionLikeSymbolPointer(callableId, signature)
+        }
+
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescEnumEntrySymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+
+internal class KtFe10DescEnumEntrySymbol(
+    override val descriptor: ClassDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtEnumEntrySymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
+    private val enumDescriptor: ClassDescriptor
+        get() = descriptor.containingDeclaration as ClassDescriptor
+
+    override val containingEnumClassIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { enumDescriptor.classId }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion {
+            val enumClassId = enumDescriptor.classId ?: return null
+            CallableId(
+                packageName = enumClassId.packageFqName,
+                className = enumClassId.relativeClassName,
+                callableName = descriptor.name
+            )
+        }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { enumDescriptor.defaultType.toKtTypeAndAnnotations(analysisSession) }
+
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override fun createPointer(): KtSymbolPointer<KtEnumEntrySymbol> = withValidityAssertion {
+        val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
+        if (pointerByPsi != null) {
+            return pointerByPsi
+        }
+
+        val enumClassId = enumDescriptor.classId
+        if (enumClassId != null) {
+            return KtFe10DescEnumEntrySymbolPointer(enumClassId, descriptor.name)
+        }
+
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescFunctionLikeSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+
+internal class KtFe10DescFunctionSymbol(
+    override val descriptor: FunctionDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFunctionSymbol(), KtFe10DescMemberSymbol<FunctionDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { descriptor.ktSymbolKind }
+
+    override val isSuspend: Boolean
+        get() = withValidityAssertion { descriptor.isSuspend }
+
+    override val isOperator: Boolean
+        get() = withValidityAssertion { descriptor.isOperator }
+
+    override val isExternal: Boolean
+        get() = withValidityAssertion { descriptor.isExternal }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { descriptor.isInline }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+    override val isInfix: Boolean
+        get() = withValidityAssertion { descriptor.isInfix }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { descriptor is JavaCallableMemberDescriptor && DescriptorUtils.isStaticDeclaration(descriptor) }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { descriptor.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { descriptor.isExtension }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+
+    override fun createPointer(): KtSymbolPointer<KtFunctionSymbol> = withValidityAssertion {
+        val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
+        if (pointerByPsi != null) {
+            return pointerByPsi
+        }
+
+        val callableId = descriptor.callableId
+        if (callableId != null && !callableId.isLocal) {
+            val signature = descriptor.getSymbolPointerSignature(analysisSession)
+            return KtFe10DescFunctionLikeSymbolPointer(callableId, signature)
+        }
+
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.callableId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtJavaFieldSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+
+internal class KtFe10DescJavaFieldSymbol(
+    override val descriptor: JavaPropertyDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtJavaFieldSymbol(), KtFe10DescMemberSymbol<JavaPropertyDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { DescriptorUtils.isStaticDeclaration(descriptor) }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !descriptor.isVar }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { descriptor.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisSession) }
+
+    override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+
+internal class KtFe10DescKotlinPropertySymbol(
+    override val descriptor: PropertyDescriptorImpl,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtKotlinPropertySymbol(), KtFe10DescMemberSymbol<PropertyDescriptorImpl> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { descriptor.ktSymbolKind }
+
+    override val isLateInit: Boolean
+        get() = withValidityAssertion { descriptor.isLateInit }
+
+    override val isConst: Boolean
+        get() = withValidityAssertion { descriptor.isConst }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !descriptor.isVar }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { descriptor.isExtension }
+
+    override val isFromPrimaryConstructor: Boolean
+        get() = withValidityAssertion { descriptor.containingDeclaration is ConstructorDescriptor }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { DescriptorUtils.isEnumEntry(descriptor) }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+    override val hasGetter: Boolean
+        get() = withValidityAssertion { descriptor.getter != null }
+
+    override val hasSetter: Boolean
+        get() = withValidityAssertion { descriptor.setter != null }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { descriptor.callableId }
+
+    override val initializer: KtConstantValue?
+        get() = withValidityAssertion { descriptor.compileTimeInitializer?.toKtConstantValue() }
+
+    override val getter: KtPropertyGetterSymbol?
+        get() = withValidityAssertion {
+            val getter = descriptor.getter ?: return null
+            return KtFe10DescPropertyGetterSymbol(getter, analysisSession)
+        }
+
+    override val setter: KtPropertySetterSymbol?
+        get() = withValidityAssertion {
+            val setter = descriptor.setter ?: return null
+            return KtFe10DescPropertySetterSymbol(setter, analysisSession)
+        }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+    override val hasBackingField: Boolean
+        get() = withValidityAssertion {
+            val bindingContext = analysisSession.resolveSession.bindingContext
+            return bindingContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] == true
+        }
+
+    override fun createPointer(): KtSymbolPointer<KtKotlinPropertySymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtLocalVariableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
+import org.jetbrains.kotlin.name.Name
+
+internal class KtFe10DescLocalVariableSymbol(
+    override val descriptor: LocalVariableDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtLocalVariableSymbol(), KtFe10DescSymbol<LocalVariableDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !descriptor.isVar }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { KtSymbolKind.LOCAL }
+
+    override fun createPointer(): KtSymbolPointer<KtLocalVariableSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescNamedClassOrObjectSymbolSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+
+internal class KtFe10DescNamedClassOrObjectSymbol(
+    override val descriptor: ClassDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtNamedClassOrObjectSymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val isInner: Boolean
+        get() = withValidityAssertion { descriptor.isInner }
+
+    override val isData: Boolean
+        get() = withValidityAssertion { descriptor.isData }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { descriptor.isInline }
+
+    override val isFun: Boolean
+        get() = withValidityAssertion { descriptor.isFun }
+
+    override val isExternal: Boolean
+        get() = withValidityAssertion { descriptor.isExternal }
+
+    override val companionObject: KtNamedClassOrObjectSymbol?
+        get() {
+            withValidityAssertion {
+                val companionObject = descriptor.companionObjectDescriptor ?: return null
+                return KtFe10DescNamedClassOrObjectSymbol(companionObject, analysisSession)
+            }
+        }
+
+    override val classKind: KtClassKind
+        get() = withValidityAssertion {
+            if (descriptor.isCompanionObject) {
+                return KtClassKind.COMPANION_OBJECT
+            } else if (DescriptorUtils.isAnonymousObject(descriptor)) {
+                error("Should be an anonymous object")
+            }
+
+            return when (descriptor.kind) {
+                ClassKind.CLASS -> KtClassKind.CLASS
+                ClassKind.INTERFACE -> KtClassKind.INTERFACE
+                ClassKind.ENUM_CLASS -> KtClassKind.ENUM_CLASS
+                ClassKind.ENUM_ENTRY -> KtClassKind.ENUM_ENTRY
+                ClassKind.ANNOTATION_CLASS -> KtClassKind.ANNOTATION_CLASS
+                ClassKind.OBJECT -> KtClassKind.OBJECT
+            }
+        }
+
+    override val superTypes: List<KtTypeAndAnnotations>
+        get() = withValidityAssertion {
+            descriptor.getSupertypesWithAny().map { it.toKtTypeAndAnnotations(analysisSession) }
+        }
+
+    override val classIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { descriptor.classId }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { descriptor.ktSymbolKind }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+
+    override fun createPointer(): KtSymbolPointer<KtNamedClassOrObjectSymbol> = withValidityAssertion {
+        val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
+        if (pointerByPsi != null) {
+            return pointerByPsi
+        }
+
+        val classId = descriptor.classId
+        if (classId != null) {
+            return KtFe10DescNamedClassOrObjectSymbolSymbol(classId)
+        }
+
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
+import org.jetbrains.kotlin.descriptors.SyntheticPropertyDescriptor
+import org.jetbrains.kotlin.descriptors.hasBody
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
+
+internal class KtFe10DescPropertyGetterSymbol(
+    override val descriptor: PropertyGetterDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtPropertyGetterSymbol(), KtFe10DescMemberSymbol<PropertyGetterDescriptor> {
+    override val isDefault: Boolean
+        get() = withValidityAssertion { descriptor.isDefault }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { descriptor.isInline }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+    override val hasBody: Boolean
+        get() = withValidityAssertion { descriptor.hasBody() }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion {
+            val propertyDescriptor = descriptor.correspondingProperty
+            return if (propertyDescriptor is SyntheticPropertyDescriptor) {
+                propertyDescriptor.getMethod.callableId
+            } else {
+                null
+            }
+        }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+    override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
+import org.jetbrains.kotlin.descriptors.SyntheticPropertyDescriptor
+import org.jetbrains.kotlin.descriptors.hasBody
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
+
+internal class KtFe10DescPropertySetterSymbol(
+    override val descriptor: PropertySetterDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtPropertySetterSymbol(), KtFe10DescMemberSymbol<PropertySetterDescriptor> {
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+
+    override val isDefault: Boolean
+        get() = withValidityAssertion { descriptor.isDefault }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { descriptor.isInline }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+    override val hasBody: Boolean
+        get() = withValidityAssertion { descriptor.hasBody() }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion {
+            val propertyDescriptor = descriptor.correspondingProperty
+            return if (propertyDescriptor is SyntheticPropertyDescriptor) {
+                propertyDescriptor.getMethod.callableId
+            } else {
+                null
+            }
+        }
+
+    override val parameter: KtValueParameterSymbol
+        get() = withValidityAssertion { KtFe10DescValueParameterSymbol(descriptor.valueParameters.single(), analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+    override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> {
+        withValidityAssertion {
+            return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+        }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescSamConstructorSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor
+
+internal class KtFe10DescSamConstructorSymbol(
+    override val descriptor: SamConstructorDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSamConstructorSymbol(), KtFe10DescSymbol<SamConstructorDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { descriptor.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { descriptor.isExtension }
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion { KtSymbolOrigin.SAM_CONSTRUCTOR }
+
+    override fun createPointer(): KtSymbolPointer<KtSamConstructorSymbol> = withValidityAssertion {
+        val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
+        if (pointerByPsi != null) {
+            return pointerByPsi
+        }
+
+        val classId = descriptor.baseDescriptorForSynthetic.classId
+        if (classId != null) {
+            return KtFe10DescSamConstructorSymbolPointer(classId)
+        }
+
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescSyntheticFieldSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtVariableLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
+import org.jetbrains.kotlin.load.kotlin.toSourceElement
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
+import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
+import org.jetbrains.kotlin.resolve.source.getPsi
+
+internal class KtFe10DescSyntheticFieldSymbol(
+    private val descriptor: SyntheticFieldDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtBackingFieldSymbol(), KtFe10Symbol {
+    override val owningProperty: KtKotlinPropertySymbol
+        get() = withValidityAssertion {
+            val kotlinProperty = descriptor.propertyDescriptor as PropertyDescriptorImpl
+            KtFe10DescKotlinPropertySymbol(kotlinProperty, analysisSession)
+        }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+    override fun createPointer(): KtSymbolPointer<KtVariableLikeSymbol> = withValidityAssertion {
+        val accessorPsi = descriptor.containingDeclaration.toSourceElement.getPsi()
+        if (accessorPsi is KtPropertyAccessor) {
+            val accessorPointer = KtPsiBasedSymbolPointer<KtPropertyAccessorSymbol>(accessorPsi.createSmartPointer())
+            return KtFe10DescSyntheticFieldSymbolPointer(accessorPointer)
+        }
+
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+
+internal class KtFe10DescSyntheticJavaPropertySymbol(
+    override val descriptor: SyntheticJavaPropertyDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSyntheticJavaPropertySymbol(), KtFe10DescMemberSymbol<SyntheticJavaPropertyDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val isFromPrimaryConstructor: Boolean
+        get() = withValidityAssertion { descriptor.containingDeclaration is ConstructorDescriptor }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { DescriptorUtils.isStaticDeclaration(descriptor) }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !descriptor.isVar }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { descriptor.isExtension }
+
+    override val getter: KtPropertyGetterSymbol
+        get() = withValidityAssertion {
+            val getter = descriptor.getter ?: return EmptyGetterSymbol(descriptor, analysisSession)
+            return KtFe10DescPropertyGetterSymbol(getter, analysisSession)
+        }
+    override val javaGetterSymbol: KtFunctionSymbol
+        get() = withValidityAssertion { KtFe10DescFunctionSymbol(descriptor.getMethod, analysisSession) }
+
+    override val javaSetterSymbol: KtFunctionSymbol?
+        get() = withValidityAssertion {
+            val setMethod = descriptor.setMethod ?: return null
+            return KtFe10DescFunctionSymbol(setMethod, analysisSession)
+        }
+
+    override val hasSetter: Boolean
+        get() = withValidityAssertion { descriptor.setter != null }
+
+    override val setter: KtPropertySetterSymbol?
+        get() = withValidityAssertion {
+            val setter = descriptor.setter ?: return null
+            KtFe10DescPropertySetterSymbol(setter, analysisSession)
+        }
+
+    override val initializer: KtConstantValue?
+        get() = withValidityAssertion { descriptor.compileTimeInitializer?.toKtConstantValue() }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { descriptor.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion { KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY }
+
+    override fun createPointer(): KtSymbolPointer<KtSyntheticJavaPropertySymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+
+    private class EmptyGetterSymbol(
+        private val descriptor: SyntheticJavaPropertyDescriptor,
+        override val analysisSession: KtFe10AnalysisSession
+    ) : KtPropertyGetterSymbol(), KtFe10Symbol {
+        override val isDefault: Boolean
+            get() = withValidityAssertion { false }
+
+        override val isInline: Boolean
+            get() = withValidityAssertion { false }
+
+        override val isOverride: Boolean
+            get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+        override val hasBody: Boolean
+            get() = withValidityAssertion { false }
+
+        override val valueParameters: List<KtValueParameterSymbol>
+            get() = withValidityAssertion { emptyList() }
+
+        override val hasStableParameterNames: Boolean
+            get() = withValidityAssertion { true }
+
+        override val callableIdIfNonLocal: CallableId?
+            get() = withValidityAssertion { null }
+
+        override val annotatedType: KtTypeAndAnnotations
+            get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+        override val origin: KtSymbolOrigin
+            get() = withValidityAssertion { KtSymbolOrigin.JAVA }
+
+        override val psi: PsiElement?
+            get() = withValidityAssertion { null }
+
+        override val receiverType: KtTypeAndAnnotations?
+            get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+        override val dispatchType: KtType?
+            get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+        override val modality: Modality
+            get() = withValidityAssertion { Modality.FINAL }
+
+        override val visibility: Visibility
+            get() = withValidityAssertion { descriptor.ktVisibility }
+
+        override val annotations: List<KtAnnotationCall>
+            get() = withValidityAssertion { emptyList() }
+
+        override fun containsAnnotation(classId: ClassId): Boolean {
+            withValidityAssertion {
+                return false
+            }
+        }
+
+        override val annotationClassIds: Collection<ClassId>
+            get() = withValidityAssertion { emptyList() }
+
+        override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> {
+            withValidityAssertion {
+                return KtFe10NeverRestoringSymbolPointer()
+            }
+        }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyDescriptor
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+
+internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
+    override val descriptor: JavaForKotlinOverridePropertyDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSyntheticJavaPropertySymbol(), KtFe10DescMemberSymbol<JavaForKotlinOverridePropertyDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val isFromPrimaryConstructor: Boolean
+        get() = withValidityAssertion { descriptor.containingDeclaration is ConstructorDescriptor }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { DescriptorUtils.isStaticDeclaration(descriptor) }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !descriptor.isVar }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { descriptor.isExtension }
+
+    override val getter: KtPropertyGetterSymbol
+        get() = withValidityAssertion {
+            val getter = descriptor.getter ?: return EmptyGetterSymbol(descriptor, analysisSession)
+            return KtFe10DescPropertyGetterSymbol(getter, analysisSession)
+        }
+    override val javaGetterSymbol: KtFunctionSymbol
+        get() = withValidityAssertion { KtFe10DescFunctionSymbol(descriptor.getterMethod, analysisSession) }
+
+    override val javaSetterSymbol: KtFunctionSymbol?
+        get() = withValidityAssertion {
+            val setMethod = descriptor.setterMethod ?: return null
+            return KtFe10DescFunctionSymbol(setMethod, analysisSession)
+        }
+
+    override val hasSetter: Boolean
+        get() = withValidityAssertion { descriptor.setter != null }
+
+    override val setter: KtPropertySetterSymbol?
+        get() = withValidityAssertion {
+            val setter = descriptor.setter ?: return null
+            KtFe10DescPropertySetterSymbol(setter, analysisSession)
+        }
+
+    override val initializer: KtConstantValue?
+        get() = withValidityAssertion { descriptor.compileTimeInitializer?.toKtConstantValue() }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { descriptor.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion { KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY }
+
+    override fun createPointer(): KtSymbolPointer<KtSyntheticJavaPropertySymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+
+    private class EmptyGetterSymbol(
+        private val descriptor: JavaForKotlinOverridePropertyDescriptor,
+        override val analysisSession: KtFe10AnalysisSession
+    ) : KtPropertyGetterSymbol(), KtFe10Symbol {
+        override val isDefault: Boolean
+            get() = withValidityAssertion { false }
+
+        override val isInline: Boolean
+            get() = withValidityAssertion { false }
+
+        override val isOverride: Boolean
+            get() = withValidityAssertion { descriptor.isExplicitOverride }
+
+        override val hasBody: Boolean
+            get() = withValidityAssertion { false }
+
+        override val valueParameters: List<KtValueParameterSymbol>
+            get() = withValidityAssertion { emptyList() }
+
+        override val hasStableParameterNames: Boolean
+            get() = withValidityAssertion { true }
+
+        override val callableIdIfNonLocal: CallableId?
+            get() = withValidityAssertion { null }
+
+        override val annotatedType: KtTypeAndAnnotations
+            get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+
+        override val origin: KtSymbolOrigin
+            get() = withValidityAssertion { KtSymbolOrigin.JAVA }
+
+        override val psi: PsiElement?
+            get() = withValidityAssertion { null }
+
+        override val receiverType: KtTypeAndAnnotations?
+            get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+
+        override val dispatchType: KtType?
+            get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+
+        override val modality: Modality
+            get() = withValidityAssertion { Modality.FINAL }
+
+        override val visibility: Visibility
+            get() = withValidityAssertion { descriptor.ktVisibility }
+
+        override val annotations: List<KtAnnotationCall>
+            get() = withValidityAssertion { emptyList() }
+
+        override fun containsAnnotation(classId: ClassId): Boolean {
+            withValidityAssertion {
+                return false
+            }
+        }
+
+        override val annotationClassIds: Collection<ClassId>
+            get() = withValidityAssertion { emptyList() }
+
+        override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> {
+            withValidityAssertion {
+                return KtFe10NeverRestoringSymbolPointer()
+            }
+        }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeAliasSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+
+internal class KtFe10DescTypeAliasSymbol(
+    override val descriptor: TypeAliasDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeAliasSymbol(), KtFe10DescSymbol<TypeAliasDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { descriptor.ktVisibility }
+
+    override val expandedType: KtType
+        get() = withValidityAssertion { descriptor.expandedType.toKtType(analysisSession) }
+
+    override val classIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { descriptor.classId }
+
+    override fun createPointer(): KtSymbolPointer<KtTypeAliasSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.Variance
+
+internal class KtFe10DescTypeParameterSymbol(
+    override val descriptor: TypeParameterDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeParameterSymbol(), KtFe10DescSymbol<TypeParameterDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion { descriptor.name }
+
+    override val upperBounds: List<KtType>
+        get() = withValidityAssertion { descriptor.upperBounds.map { it.toKtType(analysisSession) } }
+
+    override val variance: Variance
+        get() = withValidityAssertion { descriptor.variance }
+
+    override val isReified: Boolean
+        get() = withValidityAssertion { descriptor.isReified }
+
+    override fun createPointer(): KtSymbolPointer<KtTypeParameterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.SpecialNames
+import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue
+import org.jetbrains.kotlin.resolve.calls.components.isVararg
+
+internal class KtFe10DescValueParameterSymbol(
+    override val descriptor: ValueParameterDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtValueParameterSymbol(), KtFe10DescSymbol<ValueParameterDescriptor> {
+    override val name: Name
+        get() = withValidityAssertion {
+            return when (val name = descriptor.name) {
+                SpecialNames.IMPLICIT_SET_PARAMETER -> Name.identifier("value")
+                else -> name
+            }
+        }
+
+    override val hasDefaultValue: Boolean
+        get() = withValidityAssertion { descriptor.hasDefaultValue() }
+
+    override val isVararg: Boolean
+        get() = withValidityAssertion { descriptor.isVararg }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            return (descriptor.varargElementType ?: descriptor.type).toKtTypeAndAnnotations(analysisSession)
+        }
+
+    override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt

@@ -0,0 +1,299 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base
+
+import org.jetbrains.kotlin.analysis.api.KtStarProjectionTypeArgument
+import org.jetbrains.kotlin.analysis.api.KtTypeArgument
+import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
+import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.*
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.types.*
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10TypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10Renderer
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.markers.*
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
+import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
+import org.jetbrains.kotlin.resolve.constants.*
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.NewCapturedType
+import org.jetbrains.kotlin.types.checker.NewTypeVariableConstructor
+
+internal val MemberDescriptor.ktSymbolKind: KtSymbolKind
+    get() = when {
+        containingDeclaration is PackageFragmentDescriptor -> KtSymbolKind.TOP_LEVEL
+        DescriptorUtils.isLocal(this) -> KtSymbolKind.LOCAL
+        else -> KtSymbolKind.CLASS_MEMBER
+    }
+
+internal val CallableMemberDescriptor.isExplicitOverride: Boolean
+    get() {
+        return (this !is PropertyAccessorDescriptor
+                && kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE
+                && overriddenDescriptors.isNotEmpty())
+    }
+
+internal val ClassDescriptor.isInterfaceLike: Boolean
+    get() = when (kind) {
+        ClassKind.CLASS, ClassKind.ENUM_CLASS, ClassKind.OBJECT, ClassKind.ENUM_ENTRY -> false
+        else -> true
+    }
+
+internal fun DeclarationDescriptor.toKtSymbol(analysisSession: KtFe10AnalysisSession): KtSymbol? {
+    if (this is ClassDescriptor && kind == ClassKind.ENUM_ENTRY) {
+        return KtFe10DescEnumEntrySymbol(this, analysisSession)
+    }
+
+    return when (this) {
+        is ClassifierDescriptor -> toKtClassifierSymbol(analysisSession)
+        is CallableDescriptor -> toKtCallableSymbol(analysisSession)
+        else -> null
+    }
+}
+
+internal fun ClassifierDescriptor.toKtClassifierSymbol(analysisSession: KtFe10AnalysisSession): KtClassifierSymbol? {
+    return when (this) {
+        is TypeAliasDescriptor -> KtFe10DescTypeAliasSymbol(this, analysisSession)
+        is TypeParameterDescriptor -> KtFe10DescTypeParameterSymbol(this, analysisSession)
+        is ClassDescriptor -> toKtClassSymbol(analysisSession)
+        else -> null
+    }
+}
+
+internal fun ClassDescriptor.toKtClassSymbol(analysisSession: KtFe10AnalysisSession): KtClassOrObjectSymbol? {
+    return if (DescriptorUtils.isAnonymousObject(this)) {
+        KtFe10DescAnonymousObjectSymbol(this, analysisSession)
+    } else {
+        KtFe10DescNamedClassOrObjectSymbol(this, analysisSession)
+    }
+}
+
+internal fun ConstructorDescriptor.toKtConstructorSymbol(analysisSession: KtFe10AnalysisSession): KtConstructorSymbol {
+    if (this is TypeAliasConstructorDescriptor) {
+        return this.underlyingConstructorDescriptor.toKtConstructorSymbol(analysisSession)
+    }
+
+    return KtFe10DescConstructorSymbol(this, analysisSession)
+}
+
+internal val CallableMemberDescriptor.ktHasStableParameterNames: Boolean
+    get() = when {
+        this is ConstructorDescriptor && isPrimary && constructedClass.kind == ClassKind.ANNOTATION_CLASS -> true
+        isExpect -> false
+        else -> when (this) {
+            is JavaCallableMemberDescriptor -> false
+            else -> hasStableParameterNames()
+        }
+    }
+
+internal fun CallableDescriptor.toKtCallableSymbol(analysisSession: KtFe10AnalysisSession): KtCallableSymbol? {
+    return when (this) {
+        is PropertyGetterDescriptor -> KtFe10DescPropertyGetterSymbol(this, analysisSession)
+        is PropertySetterDescriptor -> KtFe10DescPropertySetterSymbol(this, analysisSession)
+        is SamConstructorDescriptor -> KtFe10DescSamConstructorSymbol(this, analysisSession)
+        is ConstructorDescriptor -> toKtConstructorSymbol(analysisSession)
+        is FunctionDescriptor -> {
+            if (DescriptorUtils.isAnonymousFunction(this)) {
+                KtFe10DescAnonymousFunctionSymbol(this, analysisSession)
+            } else {
+                KtFe10DescFunctionSymbol(this, analysisSession)
+            }
+        }
+        is SyntheticFieldDescriptor -> KtFe10DescSyntheticFieldSymbol(this, analysisSession)
+        is LocalVariableDescriptor -> KtFe10DescLocalVariableSymbol(this, analysisSession)
+        is ValueParameterDescriptor -> KtFe10DescValueParameterSymbol(this, analysisSession)
+        is SyntheticJavaPropertyDescriptor -> KtFe10DescSyntheticJavaPropertySymbol(this, analysisSession)
+        is JavaForKotlinOverridePropertyDescriptor -> KtFe10DescSyntheticJavaPropertySymbolForOverride(this, analysisSession)
+        is JavaPropertyDescriptor -> KtFe10DescJavaFieldSymbol(this, analysisSession)
+        is PropertyDescriptorImpl -> KtFe10DescKotlinPropertySymbol(this, analysisSession)
+        else -> null
+    }
+}
+
+internal fun KotlinType.toKtType(analysisSession: KtFe10AnalysisSession): KtType {
+    return when (val unwrappedType = unwrap()) {
+        is FlexibleType -> KtFe10FlexibleType(unwrappedType, analysisSession)
+        is DefinitelyNotNullType -> KtFe10DefinitelyNotNullType(unwrappedType, analysisSession)
+        is ErrorType -> KtFe10ClassErrorType(unwrappedType, analysisSession)
+        is CapturedType -> KtFe10CapturedType(unwrappedType, analysisSession)
+        is NewCapturedType -> KtFe10NewCapturedType(unwrappedType, analysisSession)
+        is SimpleType -> {
+            val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(unwrappedType)
+            if (typeParameterDescriptor != null) {
+                return KtFe10TypeParameterType(unwrappedType, typeParameterDescriptor, analysisSession)
+            }
+
+            val typeConstructor = unwrappedType.constructor
+
+            if (typeConstructor is NewTypeVariableConstructor) {
+                val newTypeParameterDescriptor = typeConstructor.originalTypeParameter
+                return if (newTypeParameterDescriptor != null) {
+                    KtFe10TypeParameterType(unwrappedType, newTypeParameterDescriptor, analysisSession)
+                } else {
+                    KtFe10ClassErrorType(ErrorUtils.createErrorType("Unresolved type parameter type") as ErrorType, analysisSession)
+                }
+            }
+
+            if (typeConstructor is IntersectionTypeConstructor) {
+                return KtFe10IntersectionType(unwrappedType, typeConstructor.supertypes, analysisSession)
+            }
+
+            return when (val typeDeclaration = typeConstructor.declarationDescriptor) {
+                is FunctionClassDescriptor -> KtFe10FunctionalType(unwrappedType, typeDeclaration, analysisSession)
+                is ClassDescriptor -> KtFe10UsualClassType(unwrappedType, typeDeclaration, analysisSession)
+                else -> {
+                    val errorType = ErrorUtils.createErrorTypeWithCustomConstructor("Unresolved class type", typeConstructor)
+                    KtFe10ClassErrorType(errorType as ErrorType, analysisSession)
+                }
+            }
+
+        }
+        else -> error("Unexpected type $this")
+    }
+}
+
+internal fun KotlinType.toKtTypeAndAnnotations(analysisSession: KtFe10AnalysisSession): KtTypeAndAnnotations {
+    return KtFe10TypeAndAnnotations(toKtType(analysisSession), this, analysisSession.token)
+}
+
+internal fun TypeProjection.toKtTypeArgument(analysisSession: KtFe10AnalysisSession): KtTypeArgument {
+    return if (isStarProjection) {
+        KtStarProjectionTypeArgument(analysisSession.token)
+    } else {
+        KtTypeArgumentWithVariance(type.toKtType(analysisSession), this.projectionKind, analysisSession.token)
+    }
+}
+
+internal val KotlinType.ktNullability: KtTypeNullability
+    get() = when {
+        this.isNullabilityFlexible() -> KtTypeNullability.UNKNOWN
+        this.isMarkedNullable -> KtTypeNullability.NULLABLE
+        else -> KtTypeNullability.NON_NULLABLE
+    }
+
+internal val DeclarationDescriptorWithVisibility.ktVisibility: Visibility
+    get() = when (visibility) {
+        DescriptorVisibilities.PUBLIC -> Visibilities.Public
+        DescriptorVisibilities.PROTECTED -> Visibilities.Protected
+        DescriptorVisibilities.INTERNAL -> Visibilities.Internal
+        DescriptorVisibilities.PRIVATE -> Visibilities.Private
+        DescriptorVisibilities.PRIVATE_TO_THIS -> Visibilities.PrivateToThis
+        DescriptorVisibilities.LOCAL -> Visibilities.Local
+        DescriptorVisibilities.INVISIBLE_FAKE -> Visibilities.InvisibleFake
+        DescriptorVisibilities.INHERITED -> Visibilities.Inherited
+        else -> Visibilities.Unknown
+    }
+
+internal fun ConstantValue<*>.toKtConstantValue(): KtConstantValue {
+    return when (this) {
+        is BooleanValue -> KtLiteralConstantValue(ConstantValueKind.Boolean, value, null)
+        is CharValue -> KtLiteralConstantValue(ConstantValueKind.Char, value, null)
+        is ByteValue -> KtLiteralConstantValue(ConstantValueKind.Byte, value, null)
+        is UByteValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedByte, value, null)
+        is ShortValue -> KtLiteralConstantValue(ConstantValueKind.Short, value, null)
+        is UShortValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedShort, value, null)
+        is IntValue -> KtLiteralConstantValue(ConstantValueKind.Int, value, null)
+        is UIntValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedInt, value, null)
+        is LongValue -> KtLiteralConstantValue(ConstantValueKind.Long, value, null)
+        is ULongValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedLong, value, null)
+        is FloatValue -> KtLiteralConstantValue(ConstantValueKind.Float, value, null)
+        is DoubleValue -> KtLiteralConstantValue(ConstantValueKind.Double, value, null)
+        is NullValue -> KtLiteralConstantValue(ConstantValueKind.Null, null, null)
+        is StringValue -> KtLiteralConstantValue(ConstantValueKind.String, value, null)
+        is ArrayValue -> KtArrayConstantValue(value.map { it.toKtConstantValue() }, null)
+        is EnumValue -> KtEnumEntryConstantValue(CallableId(enumClassId, enumEntryName), null)
+        is AnnotationValue -> {
+            val arguments = value.allValueArguments.map { (name, v) -> KtNamedConstantValue(name.asString(), v.toKtConstantValue()) }
+            KtAnnotationConstantValue(value.annotationClass?.classId, arguments, null)
+        }
+        else -> KtUnsupportedConstantValue
+    }
+}
+
+internal val CallableMemberDescriptor.callableId: CallableId?
+    get() {
+        var current: DeclarationDescriptor = containingDeclaration
+
+        val localName = mutableListOf<String>()
+        val className = mutableListOf<String>()
+
+        while (true) {
+            when (current) {
+                is PackageFragmentDescriptor -> {
+                    return CallableId(
+                        packageName = current.fqName,
+                        className = if (className.isNotEmpty()) FqName.fromSegments(className.asReversed()) else null,
+                        callableName = name,
+                        pathToLocal = if (localName.isNotEmpty()) FqName.fromSegments(localName.asReversed()) else null
+                    )
+                }
+                is ClassDescriptor -> className += current.name.asString()
+                is PropertyAccessorDescriptor -> {} // Filter out property accessors
+                is CallableDescriptor -> localName += current.name.asString()
+            }
+
+            current = current.containingDeclaration ?: return null
+        }
+    }
+
+internal fun getSymbolDescriptor(symbol: KtSymbol): DeclarationDescriptor? {
+    return when (symbol) {
+        is KtFe10DescSymbol<*> -> symbol.descriptor
+        is KtFe10PsiSymbol<*, *> -> symbol.descriptor
+        else -> null
+    }
+}
+
+internal val ClassifierDescriptor.classId: ClassId?
+    get() = when (val owner = containingDeclaration) {
+        is PackageFragmentDescriptor -> ClassId(owner.fqName, name)
+        is ClassifierDescriptorWithTypeParameters -> owner.classId?.createNestedClassId(name)
+        else -> null
+    }
+
+internal val ClassifierDescriptor.maybeLocalClassId: ClassId
+    get() = classId ?: ClassId(containingPackage() ?: FqName.ROOT, FqName.topLevel(this.name), true)
+
+internal fun ClassDescriptor.getSupertypesWithAny(): Collection<KotlinType> {
+    val supertypes = typeConstructor.supertypes
+    if (isInterfaceLike) {
+        return supertypes
+    }
+
+    val hasClassSupertype = supertypes.any { (it.constructor.declarationDescriptor as? ClassDescriptor)?.kind == ClassKind.CLASS }
+    return if (hasClassSupertype) supertypes else listOf(builtIns.anyType) + supertypes
+}
+
+internal fun DeclarationDescriptor.render(analysisSession: KtFe10AnalysisSession, options: KtDeclarationRendererOptions): String {
+    val renderer = KtFe10Renderer(analysisSession, options)
+    val consumer = StringBuilder()
+    renderer.render(this, consumer)
+    return consumer.toString().trim()
+}
+
+internal fun CallableMemberDescriptor.getSymbolPointerSignature(analysisSession: KtFe10AnalysisSession): String {
+    return render(analysisSession, KtDeclarationRendererOptions.DEFAULT)
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/KtFe10DescMemberSymbol.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base
+
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithModality
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.MemberDescriptor
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
+
+internal interface KtFe10DescMemberSymbol<T : MemberDescriptor> :
+    KtFe10DescSymbol<T>, KtSymbolWithVisibility, KtSymbolWithModality, KtSymbolWithKind {
+    override val modality: Modality
+        get() = withValidityAssertion { descriptor.modality }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { descriptor.ktVisibility }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/KtFe10DescSymbol.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10AnnotatedSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource
+import org.jetbrains.kotlin.descriptors.SourceElement
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
+import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
+import org.jetbrains.kotlin.resolve.source.PsiSourceElement
+
+internal interface KtFe10DescSymbol<T : DeclarationDescriptor> : KtFe10Symbol, KtFe10AnnotatedSymbol {
+    val descriptor: T
+
+    override val annotationsObject: Annotations
+        get() = descriptor.annotations
+
+    val source: SourceElement
+        get() {
+            val descriptor = this.descriptor
+            if (descriptor is CallableMemberDescriptor && descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+                val firstOverridden = descriptor.overriddenDescriptors.firstOrNull()
+                if (firstOverridden != null) {
+                    return firstOverridden.source
+                }
+            }
+
+            return (descriptor as? DeclarationDescriptorWithSource)?.source ?: SourceElement.NO_SOURCE
+        }
+
+    override val psi: PsiElement?
+        get() = withValidityAssertion { (source as? PsiSourceElement)?.psi }
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion {
+            val descriptor = this.descriptor
+            if (descriptor is CallableMemberDescriptor) {
+                // TODO: Add SUBSTITUTION_OVERRIDE when supported in HL API
+                when (descriptor.kind) {
+                    CallableMemberDescriptor.Kind.FAKE_OVERRIDE -> return KtSymbolOrigin.INTERSECTION_OVERRIDE
+                    CallableMemberDescriptor.Kind.SYNTHESIZED -> return KtSymbolOrigin.SOURCE_MEMBER_GENERATED
+                    else -> {}
+                }
+            }
+
+            when (source) {
+                is KotlinSourceElement -> KtSymbolOrigin.SOURCE
+                is JavaSourceElement -> KtSymbolOrigin.JAVA
+                else -> KtSymbolOrigin.LIBRARY
+            }
+        }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+
+class KtFe10DescEnumEntrySymbolPointer(private val classId: ClassId, private val entryName: Name) : KtSymbolPointer<KtEnumEntrySymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtEnumEntrySymbol? {
+        check(analysisSession is KtFe10AnalysisSession)
+        val entryDescriptor = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
+            ?.unsubstitutedMemberScope
+            ?.getContributedClassifier(entryName, NoLookupLocation.FROM_IDE)
+
+        if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) {
+            return KtFe10DescEnumEntrySymbol(entryDescriptor, analysisSession)
+        }
+
+        return null
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolPointerSignature
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+
+class KtFe10DescFunctionLikeSymbolPointer<T : KtFunctionLikeSymbol>(
+    private val callableId: CallableId,
+    private val signature: String
+) : KtSymbolPointer<T>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): T? {
+        check(analysisSession is KtFe10AnalysisSession)
+
+        val className = callableId.className
+        val memberScope = if (className != null) {
+            val outerClassId = ClassId(callableId.packageName, className, false)
+            analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(outerClassId)
+                ?.unsubstitutedMemberScope
+                ?: MemberScope.Empty
+        } else {
+            analysisSession.resolveSession.moduleDescriptor.getPackage(callableId.packageName).memberScope
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        return memberScope
+            .getContributedDescriptors(DescriptorKindFilter.CALLABLES) { it == callableId.callableName }
+            .filterIsInstance<CallableMemberDescriptor>()
+            .firstOrNull { it.getSymbolPointerSignature(analysisSession) == signature }
+            ?.toKtCallableSymbol(analysisSession) as? T
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
+import org.jetbrains.kotlin.name.ClassId
+
+class KtFe10DescNamedClassOrObjectSymbolSymbol(private val classId: ClassId) : KtSymbolPointer<KtNamedClassOrObjectSymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtNamedClassOrObjectSymbol? {
+        check(analysisSession is KtFe10AnalysisSession)
+        val descriptor = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
+        return KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisSession)
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescSamConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
+import org.jetbrains.kotlin.load.java.sam.JvmSamConversionOracle
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.resolve.sam.createSamConstructorFunction
+import org.jetbrains.kotlin.resolve.sam.getSingleAbstractMethodOrNull
+
+class KtFe10DescSamConstructorSymbolPointer(private val classId: ClassId) : KtSymbolPointer<KtSamConstructorSymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtSamConstructorSymbol? {
+        check(analysisSession is KtFe10AnalysisSession)
+        val samInterface = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
+        if (samInterface == null || getSingleAbstractMethodOrNull(samInterface) == null) {
+            return null
+        }
+
+        val constructorDescriptor = createSamConstructorFunction(
+            samInterface.containingDeclaration,
+            samInterface,
+            analysisSession.resolveSession.samConversionResolver,
+            JvmSamConversionOracle(analysisSession.resolveSession.languageVersionSettings)
+        )
+
+        return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisSession)
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescSyntheticFieldSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
+import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
+import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
+
+class KtFe10DescSyntheticFieldSymbolPointer(
+    private val psiPointer: KtPsiBasedSymbolPointer<KtPropertyAccessorSymbol>
+) : KtSymbolPointer<KtBackingFieldSymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtBackingFieldSymbol? {
+        check(analysisSession is KtFe10AnalysisSession)
+
+        @Suppress("DEPRECATION")
+        val accessorSymbol = psiPointer.restoreSymbol(analysisSession) ?: return null
+
+        val accessorDescriptor = getSymbolDescriptor(accessorSymbol) as? PropertyAccessorDescriptor ?: return null
+        val syntheticFieldDescriptor = SyntheticFieldDescriptor(accessorDescriptor, accessorDescriptor.correspondingProperty.source)
+        return KtFe10DescSyntheticFieldSymbol(syntheticFieldDescriptor, analysisSession)
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10NeverRestoringSymbolPointer.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+
+internal class KtFe10NeverRestoringSymbolPointer<T : KtSymbol> : KtSymbolPointer<T>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol", ReplaceWith("null"))
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): T? {
+        return null
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.name.FqName
+
+internal class KtFe10PackageSymbolPointer(private val packageName: FqName) : KtSymbolPointer<KtPackageSymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtPackageSymbol {
+        check(analysisSession is KtFe10AnalysisSession)
+        return KtFe10PackageSymbol(packageName, analysisSession)
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiAnonymousFunctionSymbol(
+    override val psi: KtNamedFunction,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtAnonymousFunctionSymbol(), KtFe10PsiSymbol<KtNamedFunction, FunctionDescriptor> {
+    override val descriptor: FunctionDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.FUNCTION, psi]
+    }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { true }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion {
+            descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { psi.isExtensionDeclaration() }
+
+    override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiAnonymousObjectSymbol(
+    override val psi: KtObjectDeclaration,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtAnonymousObjectSymbol(), KtFe10PsiSymbol<KtObjectDeclaration, ClassDescriptor> {
+    override val descriptor: ClassDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.CLASS, psi]
+    }
+
+    override val superTypes: List<KtTypeAndAnnotations>
+        get() = withValidityAssertion {
+            descriptor?.typeConstructor?.supertypes?.map { it.toKtTypeAndAnnotations(analysisSession) } ?: emptyList()
+        }
+
+    override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassInitializerSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.psi.KtClassInitializer
+
+class KtFe10PsiClassInitializerSymbol(
+    override val psi: KtClassInitializer,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtClassInitializerSymbol(), KtFe10Symbol {
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion {
+            return if (psi.containingKtFile.isCompiled) {
+                KtSymbolOrigin.LIBRARY
+            } else {
+                KtSymbolOrigin.SOURCE
+            }
+        }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { KtSymbolKind.CLASS_MEMBER }
+
+    override fun createPointer(): KtSymbolPointer<KtClassInitializerSymbol> {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.psi.KtConstructor
+import org.jetbrains.kotlin.psi.KtPrimaryConstructor
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiConstructorSymbol(
+    override val psi: KtConstructor<*>,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtConstructorSymbol(), KtFe10PsiSymbol<KtConstructor<*>, ConstructorDescriptor> {
+    override val descriptor: ConstructorDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.CONSTRUCTOR, psi]
+    }
+
+    override val isPrimary: Boolean
+        get() = withValidityAssertion { psi is KtPrimaryConstructor }
+
+    override val containingClassIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { psi.getContainingClassOrObject().getClassId() }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { true }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion {
+            val containingClass = descriptor?.constructedClass?.containingDeclaration as? ClassDescriptor ?: return null
+            return containingClass.defaultType.toKtType(analysisSession)
+        }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+
+    override fun createPointer(): KtSymbolPointer<KtConstructorSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiDefaultSetterParameterSymbol(
+    private val accessorPsi: KtPropertyAccessor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtValueParameterSymbol(), KtFe10Symbol {
+    private val descriptor: VariableDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(accessorPsi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.PROPERTY_ACCESSOR, accessorPsi]?.valueParameters?.single()
+    }
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion { KtSymbolOrigin.SOURCE_MEMBER_GENERATED }
+
+    override val hasDefaultValue: Boolean
+        get() = withValidityAssertion { false }
+
+    override val isVararg: Boolean
+        get() = withValidityAssertion { false }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+
+    override val psi: PsiElement?
+        get() = withValidityAssertion { null }
+
+    override val name: Name
+        get() = withValidityAssertion { descriptor?.name ?: Name.identifier("value") }
+
+    override val annotations: List<KtAnnotationCall>
+        get() = withValidityAssertion { emptyList() }
+
+    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
+        return false
+    }
+
+    override val annotationClassIds: Collection<ClassId>
+        get() = withValidityAssertion { emptyList() }
+
+    override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
+        return KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.callableId
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtEnumEntry
+import org.jetbrains.kotlin.psi.psiUtil.containingClass
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiEnumEntrySymbol(
+    override val psi: KtEnumEntry,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtEnumEntrySymbol(), KtFe10PsiSymbol<KtEnumEntry, ClassDescriptor> {
+    override val descriptor: ClassDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.CLASS, psi]
+    }
+
+    override val containingEnumClassIdIfNonLocal: ClassId?
+        get() = withValidityAssertion {
+            val containingClass = psi.containingClass()?.takeIf { it.isEnum() } ?: return null
+            return containingClass.getClassId()
+        }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { psi.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            descriptor?.defaultType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override fun createPointer(): KtSymbolPointer<KtEnumEntrySymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiFunctionSymbol(
+    override val psi: KtNamedFunction,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFunctionSymbol(), KtFe10PsiSymbol<KtNamedFunction, FunctionDescriptor> {
+    override val descriptor: FunctionDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.FUNCTION, psi]
+    }
+
+    override val isSuspend: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.SUSPEND_KEYWORD) }
+
+    override val isOperator: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.OPERATOR_KEYWORD) }
+
+    override val isExternal: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.EXTERNAL_KEYWORD) }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.INLINE_KEYWORD) }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.OVERRIDE_KEYWORD) }
+
+    override val isInfix: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.INFIX_KEYWORD) }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { false }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { true }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { psi.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion {
+            return if (psi.isExtensionDeclaration()) {
+                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            } else {
+                null
+            }
+        }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { psi.isExtensionDeclaration() }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { psi.ktSymbolKind }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion {
+            val containingClass = psi.containingClassOrObject
+            if (containingClass == null || containingClass is KtObjectDeclaration) {
+                return null
+            }
+
+            return descriptor?.dispatchReceiverParameter?.type?.toKtType(analysisSession) ?: createErrorType()
+        }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+
+    override val modality: Modality
+        get() = withValidityAssertion { psi.ktModality ?: descriptor?.modality ?: Modality.FINAL }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
+
+    override fun createPointer(): KtSymbolPointer<KtFunctionSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiKotlinPropertySymbol(
+    override val psi: KtProperty,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtKotlinPropertySymbol(), KtFe10PsiSymbol<KtProperty, PropertyDescriptor> {
+    override val descriptor: PropertyDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.VARIABLE, psi] as? PropertyDescriptor
+    }
+
+    override val isLateInit: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.LATEINIT_KEYWORD) }
+
+    override val isConst: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.CONST_KEYWORD) }
+
+    override val hasGetter: Boolean
+        get() = withValidityAssertion { psi.getter != null }
+
+    override val hasSetter: Boolean
+        get() = withValidityAssertion { psi.setter != null }
+
+    override val getter: KtPropertyGetterSymbol?
+        get() = withValidityAssertion {
+            val getter = psi.getter ?: return null
+            return KtFe10PsiPropertyGetterSymbol(getter, analysisSession)
+        }
+
+    override val setter: KtPropertySetterSymbol?
+        get() = withValidityAssertion {
+            val setter = psi.setter ?: return null
+            return KtFe10PsiPropertySetterSymbol(setter, analysisSession)
+        }
+
+    override val hasBackingField: Boolean
+        get() = withValidityAssertion {
+            val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+            bindingContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] == true
+        }
+
+    override val isFromPrimaryConstructor: Boolean
+        get() = withValidityAssertion { false }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.OVERRIDE_KEYWORD) }
+
+    override val isStatic: Boolean
+        get() = withValidityAssertion { false }
+
+    override val initializer: KtConstantValue?
+        get() = withValidityAssertion { descriptor?.compileTimeInitializer?.toKtConstantValue() }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !psi.isVar }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { psi.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion {
+            return if (psi.isExtensionDeclaration()) {
+                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            } else {
+                null
+            }
+        }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { psi.isExtensionDeclaration() }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { psi.ktSymbolKind }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion {
+            return if (!isStatic) {
+                descriptor?.dispatchReceiverParameter?.type?.toKtType(analysisSession) ?: createErrorType()
+            } else {
+                null
+            }
+        }
+
+    override val modality: Modality
+        get() = withValidityAssertion { psi.ktModality ?: descriptor?.modality ?: Modality.FINAL }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
+
+    override fun createPointer(): KtSymbolPointer<KtKotlinPropertySymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiLiteralAnonymousFunctionSymbol(
+    override val psi: KtFunctionLiteral,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtAnonymousFunctionSymbol(), KtFe10PsiSymbol<KtFunctionLiteral, FunctionDescriptor> {
+    override val descriptor: FunctionDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi)
+        bindingContext[BindingContext.FUNCTION, psi]
+    }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { true }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion {
+            descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val isExtension: Boolean
+        get() = withValidityAssertion { psi.isExtensionDeclaration() }
+
+    override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtLocalVariableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtVariableDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiLocalVariableSymbol(
+    override val psi: KtVariableDeclaration,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtLocalVariableSymbol(), KtFe10PsiSymbol<KtVariableDeclaration, VariableDescriptor> {
+    override val descriptor: VariableDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.VARIABLE, psi]
+    }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+
+    override val isVal: Boolean
+        get() = withValidityAssertion { !psi.isVar }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { KtSymbolKind.LOCAL }
+
+    override fun createPointer(): KtSymbolPointer<KtLocalVariableSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSupertypesWithAny
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktModality
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktSymbolKind
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtEnumEntry
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiNamedClassOrObjectSymbol(
+    override val psi: KtClassOrObject,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtNamedClassOrObjectSymbol(), KtFe10PsiSymbol<KtClassOrObject, ClassDescriptor> {
+    override val descriptor: ClassDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.CLASS, psi]
+    }
+
+    override val isInner: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.INNER_KEYWORD) }
+
+    override val isData: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.DATA_KEYWORD) }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.INLINE_KEYWORD) }
+
+    override val isFun: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.FUN_KEYWORD) }
+
+    override val isExternal: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.EXTERNAL_KEYWORD) }
+
+    override val companionObject: KtNamedClassOrObjectSymbol?
+        get() = withValidityAssertion {
+            val companionObject = psi.companionObjects.firstOrNull() ?: return null
+            KtFe10PsiNamedClassOrObjectSymbol(companionObject, analysisSession)
+        }
+
+    override val classKind: KtClassKind
+        get() = withValidityAssertion {
+            when (psi) {
+                is KtEnumEntry -> KtClassKind.ENUM_ENTRY
+                is KtObjectDeclaration -> when {
+                    psi.isCompanion() -> KtClassKind.COMPANION_OBJECT
+                    psi.isObjectLiteral() -> KtClassKind.ANONYMOUS_OBJECT
+                    else -> KtClassKind.OBJECT
+                }
+                is KtClass -> when {
+                    psi.isInterface() -> KtClassKind.INTERFACE
+                    psi.isEnum() -> KtClassKind.ENUM_CLASS
+                    psi.isAnnotation() -> KtClassKind.ANNOTATION_CLASS
+                    else -> KtClassKind.CLASS
+                }
+                else -> error("Unexpected class instance")
+            }
+        }
+
+    override val superTypes: List<KtTypeAndAnnotations>
+        get() = withValidityAssertion {
+            descriptor?.getSupertypesWithAny()?.map { it.toKtTypeAndAnnotations(analysisSession) } ?: emptyList()
+        }
+
+    override val classIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { psi.getClassId() }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override val symbolKind: KtSymbolKind
+        get() = withValidityAssertion { psi.ktSymbolKind }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+
+    override val modality: Modality
+        get() = withValidityAssertion { psi.ktModality ?: descriptor?.modality ?: Modality.FINAL }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
+
+    override fun createPointer(): KtSymbolPointer<KtNamedClassOrObjectSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiPropertyGetterSymbol(
+    override val psi: KtPropertyAccessor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtPropertyGetterSymbol(), KtFe10PsiSymbol<KtPropertyAccessor, PropertyGetterDescriptor> {
+    override val descriptor: PropertyGetterDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.PROPERTY_ACCESSOR, psi] as? PropertyGetterDescriptor
+    }
+
+    override val modality: Modality
+        get() = withValidityAssertion { psi.property.ktModality ?: descriptor?.modality ?: Modality.FINAL }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: psi.property.ktVisibility ?: Visibilities.Public }
+
+    override val isDefault: Boolean
+        get() = withValidityAssertion { false }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.INLINE_KEYWORD) || psi.property.hasModifier(KtTokens.INLINE_KEYWORD) }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { psi.property.hasModifier(KtTokens.OVERRIDE_KEYWORD) }
+
+    override val hasBody: Boolean
+        get() = withValidityAssertion { psi.hasBody() }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { true }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = withValidityAssertion { psi.property.callableId }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion {
+            val descriptor = this.descriptor
+            return when {
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession)
+                !psi.property.isTopLevel -> createErrorTypeAndAnnotations()
+                else -> null
+            }
+        }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion {
+            val descriptor = this.descriptor
+            return when {
+                descriptor != null -> descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession)
+                !psi.property.isTopLevel -> createErrorType()
+                else -> null
+            }
+        }
+
+    override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.*
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
+import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiPropertySetterSymbol(
+    override val psi: KtPropertyAccessor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtPropertySetterSymbol(), KtFe10PsiSymbol<KtPropertyAccessor, PropertySetterDescriptor> {
+    override val descriptor: PropertySetterDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.PROPERTY_ACCESSOR, psi] as? PropertySetterDescriptor
+    }
+
+    override val modality: Modality
+        get() = withValidityAssertion { psi.property.ktModality ?: descriptor?.modality ?: Modality.FINAL }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: psi.property.ktVisibility ?: Visibilities.Public }
+
+    override val isDefault: Boolean
+        get() = withValidityAssertion { false }
+
+    override val isInline: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.INLINE_KEYWORD) || psi.property.hasModifier(KtTokens.INLINE_KEYWORD) }
+
+    override val isOverride: Boolean
+        get() = withValidityAssertion { psi.property.hasModifier(KtTokens.OVERRIDE_KEYWORD) }
+
+    override val hasBody: Boolean
+        get() = withValidityAssertion { psi.hasBody() }
+
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion { true }
+
+    override val callableIdIfNonLocal: CallableId?
+        get() = TODO("Not yet implemented")
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+    override val receiverType: KtTypeAndAnnotations?
+        get() = withValidityAssertion {
+            val descriptor = this.descriptor
+            return when {
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession)
+                psi.property.isExtensionDeclaration() -> createErrorTypeAndAnnotations()
+                else -> null
+            }
+        }
+
+    override val dispatchType: KtType?
+        get() = withValidityAssertion {
+            val descriptor = this.descriptor
+            return when {
+                descriptor != null -> descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession)
+                !psi.property.isTopLevel -> createErrorType()
+                else -> null
+            }
+        }
+
+    override val parameter: KtValueParameterSymbol
+        get() = withValidityAssertion {
+            val parameter = psi.parameter
+            return if (parameter != null) {
+                KtFe10PsiValueParameterSymbol(parameter, analysisSession)
+            } else {
+                KtFe10PsiDefaultSetterParameterSymbol(psi, analysisSession)
+            }
+        }
+
+    override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeAliasSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtTypeAlias
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiTypeAliasSymbol(
+    override val psi: KtTypeAlias,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeAliasSymbol(), KtFe10PsiSymbol<KtTypeAlias, TypeAliasDescriptor> {
+    override val descriptor: TypeAliasDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi)
+        bindingContext[BindingContext.TYPE_ALIAS, psi]
+    }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+
+    override val visibility: Visibility
+        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
+
+    override val expandedType: KtType
+        get() = withValidityAssertion { descriptor?.expandedType?.toKtType(analysisSession) ?: createErrorType() }
+
+    override val classIdIfNonLocal: ClassId?
+        get() = withValidityAssertion { psi.getClassId() }
+
+    override fun createPointer(): KtSymbolPointer<KtTypeAliasSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtTypeParameter
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.types.Variance
+
+internal class KtFe10PsiTypeParameterSymbol(
+    override val psi: KtTypeParameter,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeParameterSymbol(), KtFe10PsiSymbol<KtTypeParameter, TypeParameterDescriptor> {
+    override val descriptor: TypeParameterDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi)
+        bindingContext[BindingContext.TYPE_PARAMETER, psi]
+    }
+
+    override val variance: Variance
+        get() = withValidityAssertion { psi.variance }
+
+    override val upperBounds: List<KtType>
+        get() = withValidityAssertion { descriptor?.upperBounds?.map { it.toKtType(analysisSession) } ?: emptyList() }
+
+    override val isReified: Boolean
+        get() = withValidityAssertion { psi.hasModifier(KtTokens.REIFIED_KEYWORD) }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override fun createPointer(): KtSymbolPointer<KtTypeParameterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.resolve.BindingContext
+
+internal class KtFe10PsiValueParameterSymbol(
+    override val psi: KtParameter,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtValueParameterSymbol(), KtFe10PsiSymbol<KtParameter, VariableDescriptor> {
+    override val descriptor: VariableDescriptor? by cached {
+        val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL)
+        bindingContext[BindingContext.VALUE_PARAMETER, psi]
+    }
+
+    override val hasDefaultValue: Boolean
+        get() = withValidityAssertion { psi.hasDefaultValue() }
+
+    override val isVararg: Boolean
+        get() = withValidityAssertion { psi.isVarArg }
+
+    override val annotatedType: KtTypeAndAnnotations
+        get() = withValidityAssertion {
+            val type = (descriptor as? ValueParameterDescriptor)?.varargElementType ?: descriptor?.type
+            return type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+        }
+
+    override val name: Name
+        get() = withValidityAssertion { psi.nameAsSafeName }
+
+    override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
+        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbol.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base
+
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10AnnotatedSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.psi.KtElement
+
+internal interface KtFe10PsiSymbol<P : KtElement, D : DeclarationDescriptor> : KtFe10Symbol, KtFe10AnnotatedSymbol {
+    override val psi: P
+    val descriptor: D?
+
+    override val annotationsObject: Annotations
+        get() = descriptor?.annotations ?: Annotations.EMPTY
+
+    override val origin: KtSymbolOrigin
+        get() = withValidityAssertion {
+            return if (psi.containingKtFile.isCompiled) {
+                KtSymbolOrigin.LIBRARY
+            } else {
+                KtSymbolOrigin.SOURCE
+            }
+        }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
+import org.jetbrains.kotlin.analysis.api.descriptors.types.KtFe10ClassErrorType
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.cfg.getElementParentDeclaration
+import org.jetbrains.kotlin.descriptors.ClassDescriptorWithResolutionScopes
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.hasBody
+import org.jetbrains.kotlin.psi.psiUtil.isTopLevelInFileOrScript
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.scopes.LexicalScope
+import org.jetbrains.kotlin.types.ErrorType
+import org.jetbrains.kotlin.types.ErrorUtils
+
+internal val KtDeclaration.ktVisibility: Visibility?
+    get() = when {
+        hasModifier(KtTokens.PUBLIC_KEYWORD) -> Visibilities.Public
+        hasModifier(KtTokens.PROTECTED_KEYWORD) -> Visibilities.Protected
+        hasModifier(KtTokens.PRIVATE_KEYWORD) -> Visibilities.Private
+        hasModifier(KtTokens.INTERNAL_KEYWORD) -> Visibilities.Internal
+        else -> null
+    }
+
+internal val KtDeclaration.ktModality: Modality?
+    get() = when {
+        hasModifier(KtTokens.ABSTRACT_KEYWORD) -> Modality.ABSTRACT
+        hasModifier(KtTokens.FINAL_KEYWORD) -> Modality.FINAL
+        hasModifier(KtTokens.SEALED_KEYWORD) -> Modality.SEALED
+        hasModifier(KtTokens.OPEN_KEYWORD) -> {
+            if (this is KtCallableDeclaration && !hasBody()) {
+                val parentDeclaration = this.getElementParentDeclaration()
+                if (parentDeclaration is KtClass && parentDeclaration.isInterface()) {
+                    Modality.ABSTRACT
+                } else {
+                    Modality.OPEN
+                }
+            }
+            Modality.OPEN
+        }
+        else -> null
+    }
+
+internal val KtElement.ktSymbolKind: KtSymbolKind
+    get() = when {
+        this is KtPropertyAccessor -> KtSymbolKind.ACCESSOR
+        isTopLevelInFileOrScript(this) -> KtSymbolKind.TOP_LEVEL
+        this is KtDeclaration && !KtPsiUtil.isLocal(this) -> KtSymbolKind.CLASS_MEMBER
+        else -> KtSymbolKind.LOCAL
+    }
+
+internal val KtDeclaration.callableId: CallableId?
+    get() {
+        val selfName = this.name ?: return null
+        val containingFile = this.containingKtFile
+
+        var current = this.getElementParentDeclaration()
+
+        val localName = mutableListOf<String>()
+        val className = mutableListOf<String>()
+
+        while (current != null) {
+            when (current) {
+                is KtClassOrObject -> className += current.name ?: return null
+                is KtPropertyAccessor -> {} // Filter out property accessors
+                is KtCallableDeclaration -> localName += current.name ?: return null
+            }
+
+            current = current.getElementParentDeclaration()
+        }
+
+        return CallableId(
+            packageName = containingFile.packageFqName,
+            className = if (className.isNotEmpty()) FqName.fromSegments(className.asReversed()) else null,
+            callableName = Name.identifier(selfName),
+            pathToLocal = if (localName.isNotEmpty()) FqName.fromSegments(localName.asReversed()) else null
+        )
+    }
+
+internal fun PsiElement.getResolutionScope(bindingContext: BindingContext): LexicalScope? {
+    for (parent in parentsWithSelf) {
+        if (parent is KtElement) {
+            val scope = bindingContext[BindingContext.LEXICAL_SCOPE, parent]
+            if (scope != null) return scope
+        }
+
+        if (parent is KtClassBody) {
+            val classDescriptor = bindingContext[BindingContext.CLASS, parent.getParent()] as? ClassDescriptorWithResolutionScopes
+            if (classDescriptor != null) {
+                return classDescriptor.scopeForMemberDeclarationResolution
+            }
+        }
+        if (parent is KtFile) {
+            break
+        }
+    }
+
+    return null
+}
+
+internal fun KtFe10Symbol.createErrorTypeAndAnnotations(): KtTypeAndAnnotations {
+    val errorType = createErrorType()
+
+    return object : KtTypeAndAnnotations() {
+        override val type: KtType
+            get() = withValidityAssertion { errorType }
+        override val annotations: List<KtAnnotationCall>
+            get() = withValidityAssertion { emptyList() }
+        override val token: ValidityToken
+            get() = this@createErrorTypeAndAnnotations.token
+
+    }
+}
+
+internal fun KtFe10Symbol.createErrorType(): KtType {
+    val type = ErrorUtils.createErrorType("Type is unavailable for declaration $psi") as ErrorType
+    return KtFe10ClassErrorType(type, analysisSession)
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.types.KtCapturedType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
+
+internal class KtFe10CapturedType(
+    override val type: CapturedType,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtCapturedType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val nullability: KtTypeNullability
+        get() = withValidityAssertion { type.ktNullability }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.types.KtClassErrorType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.types.ErrorType
+
+internal class KtFe10ClassErrorType(
+    override val type: ErrorType,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtClassErrorType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val error: String
+        get() = withValidityAssertion { "Type \"${type.presentableName}\" is unresolved" }
+
+    override val candidateClassSymbols: Collection<KtClassLikeSymbol>
+        get() = withValidityAssertion { emptyList() }
+
+    override val nullability: KtTypeNullability
+        get() = withValidityAssertion { type.ktNullability }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.types.KtDefinitelyNotNullType
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.types.DefinitelyNotNullType
+
+internal class KtFe10DefinitelyNotNullType(
+    override val type: DefinitelyNotNullType,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtDefinitelyNotNullType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val original: KtType
+        get() = withValidityAssertion { type.original.toKtType(analysisSession) }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.types.KtFlexibleType
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.types.FlexibleType
+
+internal class KtFe10FlexibleType(
+    override val type: FlexibleType,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFlexibleType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val lowerBound: KtType
+        get() = withValidityAssertion { type.lowerBound.toKtType(analysisSession) }
+
+    override val upperBound: KtType
+        get() = withValidityAssertion { type.upperBound.toKtType(analysisSession) }
+
+    override val nullability: KtTypeNullability
+        get() = withValidityAssertion { type.ktNullability }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.KtTypeArgument
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeArgument
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+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.api.withValidityAssertion
+import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.getReceiverTypeFromFunctionType
+import org.jetbrains.kotlin.builtins.getReturnTypeFromFunctionType
+import org.jetbrains.kotlin.builtins.getValueParameterTypesFromFunctionType
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.types.SimpleType
+
+internal class KtFe10FunctionalType(
+    override val type: SimpleType,
+    private val descriptor: FunctionClassDescriptor,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtFunctionalType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val nullability: KtTypeNullability
+        get() = withValidityAssertion { type.ktNullability }
+
+    override val isSuspend: Boolean
+        get() = withValidityAssertion { descriptor.functionKind.isSuspendType }
+
+    override val arity: Int
+        get() = withValidityAssertion { descriptor.arity }
+
+    override val hasReceiver: Boolean
+        get() = withValidityAssertion { type.getReceiverTypeFromFunctionType() != null }
+
+    override val receiverType: KtType?
+        get() = withValidityAssertion { type.getReceiverTypeFromFunctionType()?.toKtType(analysisSession) }
+
+    override val parameterTypes: List<KtType>
+        get() = withValidityAssertion { type.getValueParameterTypesFromFunctionType().map { it.type.toKtType(analysisSession) } }
+
+    override val returnType: KtType
+        get() = withValidityAssertion { type.getReturnTypeFromFunctionType().toKtType(analysisSession) }
+
+    override val classId: ClassId
+        get() = ClassId(descriptor.functionKind.packageFqName, descriptor.functionKind.numberedClassName(descriptor.arity))
+
+    override val classSymbol: KtClassLikeSymbol
+        get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisSession) }
+
+    override val typeArguments: List<KtTypeArgument>
+        get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisSession) } }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.types.KtIntersectionType
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.SimpleType
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
+
+internal class KtFe10IntersectionType(
+    override val type: SimpleType,
+    private val supertypes: Collection<KotlinType>,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtIntersectionType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val conjuncts: List<KtType> by cached {
+        val result = ArrayList<KtType>(supertypes.size)
+        val isNullable = type.isMarkedNullable
+        for (supertype in supertypes) {
+            val mappedSupertype = if (isNullable) supertype.makeNullable() else supertype
+            result += mappedSupertype.toKtType(analysisSession)
+        }
+        return@cached result
+    }
+
+    override val nullability: KtTypeNullability
+        get() = withValidityAssertion { type.ktNullability }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.types
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
+import org.jetbrains.kotlin.analysis.api.descriptors.types.base.asStringForDebugging
+import org.jetbrains.kotlin.analysis.api.types.KtCapturedType
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.types.checker.NewCapturedType
+
+internal class KtFe10NewCapturedType(
+    override val type: NewCapturedType,
+    override val analysisSession: KtFe10AnalysisSession
+) : KtCapturedType(), KtFe10Type {
+    override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
+
+    override val nullability: KtTypeNullability
+        get() = withValidityAssertion { type.ktNullability }
+}