diff --git a/analysis/analysis-api-fe10/build.gradle.kts b/analysis/analysis-api-fe10/build.gradle.kts new file mode 100644 index 00000000000..7830eeb8935 --- /dev/null +++ b/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> { + kotlinOptions { + freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn" + } +} + +projectTest(jUnit5Enabled = true) { + dependsOn(":dist") + workingDir = rootDir + useJUnitPlatform() +} + +testsJar() \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt new file mode 100644 index 00000000000..c0a6c7bcbba --- /dev/null +++ b/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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt new file mode 100644 index 00000000000..b236cab5c27 --- /dev/null +++ b/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() {} +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CallResolver.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CallResolver.kt new file mode 100644 index 00000000000..7495c7c0f32 --- /dev/null +++ b/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() + 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 { + val result = LinkedHashMap() + 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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt new file mode 100644 index 00000000000..2e9cf50e96b --- /dev/null +++ b/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() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompletionCandidateChecker.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompletionCandidateChecker.kt new file mode 100644 index 00000000000..4562ccd5228 --- /dev/null +++ b/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") + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10DiagnosticProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10DiagnosticProvider.kt new file mode 100644 index 00000000000..43ba605a6a7 --- /dev/null +++ b/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> { + 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> { + withValidityAssertion { + val bindingContext = analysisSession.analyze(ktFile) + val result = mutableListOf>() + 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 { + 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? + return factory?.defaultRenderer?.render(diagnostic) ?: "" + } + + override val psi: PsiElement + get() = diagnostic.psiElement + + override val textRanges: Collection + get() = diagnostic.textRanges + + override val diagnosticClass: KClass> + get() = KtFe10Diagnostic::class +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionInfoProvider.kt new file mode 100644 index 00000000000..40ee340f6d9 --- /dev/null +++ b/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 = withValidityAssertion { + val bindingContext = analysisSession.analyze(whenExpression) + return WhenChecker.getMissingCases(whenExpression, bindingContext) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt new file mode 100644 index 00000000000..bcfcd171274 --- /dev/null +++ b/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(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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ImportOptimizer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ImportOptimizer.kt new file mode 100644 index 00000000000..99b34a4eb20 --- /dev/null +++ b/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() + val importedPackages = HashSet() + + 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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10InheritorsProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10InheritorsProvider.kt new file mode 100644 index 00000000000..64326a86895 --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + val enumDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList() + if (enumDescriptor.kind != ClassKind.ENUM_CLASS) { + return emptyList() + } + + val result = mutableListOf() + + for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) { + if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) { + result += KtFe10DescEnumEntrySymbol(entryDescriptor, analysisSession) + } + } + + return result + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10JvmTypeMapper.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10JvmTypeMapper.kt new file mode 100644 index 00000000000..b5756cd575b --- /dev/null +++ b/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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt new file mode 100644 index 00000000000..eb1acafff32 --- /dev/null +++ b/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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt new file mode 100644 index 00000000000..6850f8c5885 --- /dev/null +++ b/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")) { + 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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceShortener.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceShortener.kt new file mode 100644 index 00000000000..81ee074b64c --- /dev/null +++ b/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() {} + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SamResolver.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SamResolver.kt new file mode 100644 index 00000000000..18f7e4cd20f --- /dev/null +++ b/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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ScopeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ScopeProvider.kt new file mode 100644 index 00000000000..d9a3579c725 --- /dev/null +++ b/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(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(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(symbol) ?: return KtFe10EmptyScope(token) + return KtFe10ScopeMember(descriptor.staticScope, analysisSession) + } + + override fun getFileScope(fileSymbol: KtFileSymbol): KtDeclarationScope = withValidityAssertion { + require(fileSymbol is KtFe10FileSymbol) + val scope = analysisSession.resolveSession.fileScopeProvider.getFileResolutionScope(fileSymbol.psi) + + return object : KtFe10ScopeLexical(scope, analysisSession), KtDeclarationScope { + 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): 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 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 { + val result = mutableListOf() + + 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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SmartCastProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SmartCastProvider.kt new file mode 100644 index 00000000000..5e7c15574b1 --- /dev/null +++ b/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 { + 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) + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SubtypingComponent.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SubtypingComponent.kt new file mode 100644 index 00000000000..5e260331d43 --- /dev/null +++ b/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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt new file mode 100644 index 00000000000..31319229a00 --- /dev/null +++ b/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 + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationOverridesProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationOverridesProvider.kt new file mode 100644 index 00000000000..28b8914ac0e --- /dev/null +++ b/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 getAllOverriddenSymbols(callableSymbol: T): List { + val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList() + return getOverriddenDescriptors(descriptor, true).mapNotNull { it.toKtCallableSymbol(analysisSession) } + } + + override fun getDirectlyOverriddenSymbols(callableSymbol: T): List { + val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList() + return getOverriddenDescriptors(descriptor, false).mapNotNull { it.toKtCallableSymbol(analysisSession) } + } + + private fun getOverriddenDescriptors( + descriptor: CallableMemberDescriptor, + collectAllOverrides: Boolean + ): Collection { + val overriddenDescriptors = LinkedHashSet() + val queue = ArrayDeque().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 = withValidityAssertion { + throw NotImplementedError("Method is not implemented for FE 1.0") + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt new file mode 100644 index 00000000000..23a1b147a13 --- /dev/null +++ b/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() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolInfoProvider.kt new file mode 100644 index 00000000000..0c36d7bc214 --- /dev/null +++ b/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)) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolProvider.kt new file mode 100644 index 00000000000..429adeb0149 --- /dev/null +++ b/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 = 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 } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeCreator.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeCreator.kt new file mode 100644 index 00000000000..f721ae2a546 --- /dev/null +++ b/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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt new file mode 100644 index 00000000000..8c0793c5800 --- /dev/null +++ b/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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt new file mode 100644 index 00000000000..ad6125f4977 --- /dev/null +++ b/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 = 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 { + 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 { + require(type is KtFe10Type) + return TypeUtils.getImmediateSupertypes(type.type).map { it.toKtType(analysisSession) } + } + + override fun getAllSuperTypes(type: KtType, shouldApproximate: Boolean): List { + 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 { + 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, + lowerBounds: Set, + checkedTypeParameters: MutableSet = 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): Map { + val typeArgumentMapping = LinkedHashMap() + for (type in upperBounds) { + val mappingForType = type.toTypeArgumentMapping() ?: continue + + val queue = ArrayDeque() + 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 { + 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 { + 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 = emptyMap() + ): TypeArgumentMapping? { + val typeParameterOwner = constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters ?: return null + + val mapping = mutableMapOf() + 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 + ) + + private data class BoundTypeArgument(val type: KotlinType, val variance: Variance) + private data class BoundTypeArguments(val upper: MutableSet, val lower: MutableSet, val isCompatible: Boolean) + + private fun computeLeafClassesOrInterfaces(upperBoundClasses: Set): Set { + val isLeaf = mutableMapOf() + 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 { + val initialClass = getBoundClass(type) ?: return emptySet() + + val result = mutableSetOf() + result.add(initialClass) + + val queue = ArrayDeque() + 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): 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) } + +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt new file mode 100644 index 00000000000..42daa09fca8 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt new file mode 100644 index 00000000000..7debbbd017e --- /dev/null +++ b/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 { + 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") + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt new file mode 100644 index 00000000000..5693fb6af80 --- /dev/null +++ b/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 { + 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)) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt new file mode 100644 index 00000000000..3cebf929ce8 --- /dev/null +++ b/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 { + require(this is KtFe10AnalysisSession) + + val bindingContext = analyze(expression, KtFe10AnalysisSession.AnalysisMode.PARTIAL) + val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor + return listOfNotNull(descriptor?.toKtCallableSymbol(this)) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt new file mode 100644 index 00000000000..dd62a764967 --- /dev/null +++ b/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 { + 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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt new file mode 100644 index 00000000000..51a404ec6c9 --- /dev/null +++ b/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 { + 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) } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt new file mode 100644 index 00000000000..cb57f6d5677 --- /dev/null +++ b/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 { + 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") + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt new file mode 100644 index 00000000000..03a71361bf7 --- /dev/null +++ b/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 { + 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() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt new file mode 100644 index 00000000000..b3242352c37 --- /dev/null +++ b/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 { + 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") + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10KotlinReferenceProviderContributor.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10KotlinReferenceProviderContributor.kt new file mode 100644 index 00000000000..e5f5175a1f5 --- /dev/null +++ b/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) + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt new file mode 100644 index 00000000000..c4024e4879d --- /dev/null +++ b/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 { + @OptIn(HackToForceAllowRunningAnalyzeOnEDT::class) + override fun resolve(reference: KtReference, incompleteCode: Boolean): Array { + 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() + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10Reference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10Reference.kt new file mode 100644 index 00000000000..12e3777557d --- /dev/null +++ b/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 + get() = KtFe10PolyVariantResolver +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10EmptyScope.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10EmptyScope.kt new file mode 100644 index 00000000000..d776d3e4a22 --- /dev/null +++ b/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 = withValidityAssertion { + return emptySet() + } + + override fun getPossibleCallableNames(): Set = withValidityAssertion { + return emptySet() + } + + override fun getPossibleClassifierNames(): Set = withValidityAssertion { + return emptySet() + } + + override fun getAllSymbols(): Sequence = withValidityAssertion { + return emptySequence() + } + + override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence = withValidityAssertion { + return emptySequence() + } + + override fun getClassifierSymbols(nameFilter: KtScopeNameFilter): Sequence = withValidityAssertion { + return emptySequence() + } + + override fun getConstructors(): Sequence = withValidityAssertion { + return emptySequence() + } + + override fun mayContainName(name: Name): Boolean = withValidityAssertion { + return false + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt new file mode 100644 index 00000000000..c0fd8c4fc05 --- /dev/null +++ b/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 = withValidityAssertion { + val packageFragmentProvider = analysisSession.resolveSession.packageFragmentProvider + return packageFragmentProvider.getSubPackagesOf(owner.fqName, nameFilter) + .asSequence() + .map { KtFe10PackageSymbol(it, analysisSession) } + } + + override fun getConstructors(): Sequence = withValidityAssertion { + return emptySequence() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt new file mode 100644 index 00000000000..00e69cf2bb4 --- /dev/null +++ b/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 = 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 = withValidityAssertion { + return scope + .getContributedDescriptors(kindFilter = DescriptorKindFilter.CLASSIFIERS, nameFilter) + .asSequence() + .filter { nameFilter(it.name) } + .mapNotNull { it.toKtSymbol(analysisSession) as? KtClassifierSymbol } + } + + override fun getConstructors(): Sequence = withValidityAssertion { + return scope + .getContributedDescriptors(kindFilter = DescriptorKindFilter.FUNCTIONS) + .asSequence() + .filterIsInstance() + .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 = withValidityAssertion { + return emptySet() + } + + override fun getPossibleClassifierNames(): Set = withValidityAssertion { + return emptySet() + } +} + +internal open class KtFe10ScopeMember( + override val scope: MemberScope, + override val analysisSession: KtFe10AnalysisSession +) : KtFe10ScopeResolution(), ValidityTokenOwner { + override fun getPossibleCallableNames(): Set = withValidityAssertion { + return scope.getFunctionNames() + scope.getVariableNames() + } + + override fun getPossibleClassifierNames(): Set = withValidityAssertion { + return scope.getClassifierNames() ?: emptySet() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt new file mode 100644 index 00000000000..8216340d70e --- /dev/null +++ b/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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt new file mode 100644 index 00000000000..674e4218665 --- /dev/null +++ b/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 = 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 + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10AnnotatedSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10AnnotatedSymbol.kt new file mode 100644 index 00000000000..e28d5936367 --- /dev/null +++ b/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 + get() = withValidityAssertion { + annotationsObject.map { KtFe10DescAnnotationCall(it, token) } + } + + override val annotationClassIds: Collection + get() { + withValidityAssertion { + val result = mutableListOf() + 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()) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt new file mode 100644 index 00000000000..ae53db26cb4 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnnotationCall.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnnotationCall.kt new file mode 100644 index 00000000000..627a7ff14ee --- /dev/null +++ b/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 + get() = withValidityAssertion { + descriptor.allValueArguments.map { (name, value) -> KtNamedConstantValue(name.asString(), value.toKtConstantValue()) } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt new file mode 100644 index 00000000000..b795db4139f --- /dev/null +++ b/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 { + override val isExtension: Boolean + get() = withValidityAssertion { descriptor.isExtension } + + override val valueParameters: List + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt new file mode 100644 index 00000000000..665e97f0be2 --- /dev/null +++ b/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 { + override val superTypes: List + get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtTypeAndAnnotations(analysisSession) } } + + override fun createPointer(): KtSymbolPointer = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt new file mode 100644 index 00000000000..c543d3feee2 --- /dev/null +++ b/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 { + override val isPrimary: Boolean + get() = withValidityAssertion { descriptor.isPrimary } + + override val containingClassIdIfNonLocal: ClassId? + get() = withValidityAssertion { descriptor.constructedClass.classId } + + override val valueParameters: List + 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 + get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } } + + override fun createPointer(): KtSymbolPointer = 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() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt new file mode 100644 index 00000000000..cc0cb84fb32 --- /dev/null +++ b/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 { + 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 = 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() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt new file mode 100644 index 00000000000..40fb37575a3 --- /dev/null +++ b/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 { + 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 + 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 + get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } } + + override fun createPointer(): KtSymbolPointer = 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() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt new file mode 100644 index 00000000000..549ed70bf2c --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt new file mode 100644 index 00000000000..f6fa55835d5 --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt new file mode 100644 index 00000000000..349be16ec2b --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt new file mode 100644 index 00000000000..5d0fd3e6380 --- /dev/null +++ b/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 { + 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 + 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 + get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } } + + override fun createPointer(): KtSymbolPointer = withValidityAssertion { + val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this) + if (pointerByPsi != null) { + return pointerByPsi + } + + val classId = descriptor.classId + if (classId != null) { + return KtFe10DescNamedClassOrObjectSymbolSymbol(classId) + } + + return KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt new file mode 100644 index 00000000000..72cb81f14c0 --- /dev/null +++ b/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 { + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt new file mode 100644 index 00000000000..b8eb84ccb0a --- /dev/null +++ b/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 { + 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 + 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 { + withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt new file mode 100644 index 00000000000..44edf0c95c9 --- /dev/null +++ b/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 { + override val name: Name + get() = withValidityAssertion { descriptor.name } + + override val valueParameters: List + 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 = withValidityAssertion { + val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this) + if (pointerByPsi != null) { + return pointerByPsi + } + + val classId = descriptor.baseDescriptorForSynthetic.classId + if (classId != null) { + return KtFe10DescSamConstructorSymbolPointer(classId) + } + + return KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt new file mode 100644 index 00000000000..523bb5dd9da --- /dev/null +++ b/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 = withValidityAssertion { + val accessorPsi = descriptor.containingDeclaration.toSourceElement.getPsi() + if (accessorPsi is KtPropertyAccessor) { + val accessorPointer = KtPsiBasedSymbolPointer(accessorPsi.createSmartPointer()) + return KtFe10DescSyntheticFieldSymbolPointer(accessorPointer) + } + + return KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt new file mode 100644 index 00000000000..3245b565c36 --- /dev/null +++ b/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 { + 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 = 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 + 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 + get() = withValidityAssertion { emptyList() } + + override fun containsAnnotation(classId: ClassId): Boolean { + withValidityAssertion { + return false + } + } + + override val annotationClassIds: Collection + get() = withValidityAssertion { emptyList() } + + override fun createPointer(): KtSymbolPointer { + withValidityAssertion { + return KtFe10NeverRestoringSymbolPointer() + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt new file mode 100644 index 00000000000..343fc2c6733 --- /dev/null +++ b/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 { + 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 = 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 + 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 + get() = withValidityAssertion { emptyList() } + + override fun containsAnnotation(classId: ClassId): Boolean { + withValidityAssertion { + return false + } + } + + override val annotationClassIds: Collection + get() = withValidityAssertion { emptyList() } + + override fun createPointer(): KtSymbolPointer { + withValidityAssertion { + return KtFe10NeverRestoringSymbolPointer() + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt new file mode 100644 index 00000000000..deaad1c88eb --- /dev/null +++ b/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 { + override val name: Name + get() = withValidityAssertion { descriptor.name } + + override val typeParameters: List + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt new file mode 100644 index 00000000000..972b43dcb6f --- /dev/null +++ b/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 { + override val name: Name + get() = withValidityAssertion { descriptor.name } + + override val upperBounds: List + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt new file mode 100644 index 00000000000..167e2a125f0 --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt new file mode 100644 index 00000000000..01477a9986f --- /dev/null +++ b/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() + val className = mutableListOf() + + 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 { + 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) +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/KtFe10DescMemberSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/KtFe10DescMemberSymbol.kt new file mode 100644 index 00000000000..db528c3a618 --- /dev/null +++ b/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 : + KtFe10DescSymbol, KtSymbolWithVisibility, KtSymbolWithModality, KtSymbolWithKind { + override val modality: Modality + get() = withValidityAssertion { descriptor.modality } + + override val visibility: Visibility + get() = withValidityAssertion { descriptor.ktVisibility } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/KtFe10DescSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/KtFe10DescSymbol.kt new file mode 100644 index 00000000000..261540fae9e --- /dev/null +++ b/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 : 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 + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt new file mode 100644 index 00000000000..d6aaaa0b6d9 --- /dev/null +++ b/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() { + @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 + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt new file mode 100644 index 00000000000..bb4baf88740 --- /dev/null +++ b/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( + private val callableId: CallableId, + private val signature: String +) : KtSymbolPointer() { + @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() + .firstOrNull { it.getSymbolPointerSignature(analysisSession) == signature } + ?.toKtCallableSymbol(analysisSession) as? T + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt new file mode 100644 index 00000000000..2867e507c20 --- /dev/null +++ b/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() { + @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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt new file mode 100644 index 00000000000..213e1ad4c70 --- /dev/null +++ b/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() { + @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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt new file mode 100644 index 00000000000..f3d9ca665db --- /dev/null +++ b/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 +) : KtSymbolPointer() { + @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) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10NeverRestoringSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10NeverRestoringSymbolPointer.kt new file mode 100644 index 00000000000..76d4a42ea19 --- /dev/null +++ b/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 : KtSymbolPointer() { + @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol", ReplaceWith("null")) + override fun restoreSymbol(analysisSession: KtAnalysisSession): T? { + return null + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt new file mode 100644 index 00000000000..f00ca572b15 --- /dev/null +++ b/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() { + @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol") + override fun restoreSymbol(analysisSession: KtAnalysisSession): KtPackageSymbol { + check(analysisSession is KtFe10AnalysisSession) + return KtFe10PackageSymbol(packageName, analysisSession) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt new file mode 100644 index 00000000000..23c3f9f5da5 --- /dev/null +++ b/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 { + override val descriptor: FunctionDescriptor? by cached { + val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL) + bindingContext[BindingContext.FUNCTION, psi] + } + + override val valueParameters: List + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt new file mode 100644 index 00000000000..832f04a4e3f --- /dev/null +++ b/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 { + override val descriptor: ClassDescriptor? by cached { + val bindingContext = analysisSession.analyze(psi, KtFe10AnalysisSession.AnalysisMode.PARTIAL) + bindingContext[BindingContext.CLASS, psi] + } + + override val superTypes: List + get() = withValidityAssertion { + descriptor?.typeConstructor?.supertypes?.map { it.toKtTypeAndAnnotations(analysisSession) } ?: emptyList() + } + + override fun createPointer(): KtSymbolPointer = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt new file mode 100644 index 00000000000..810eaf5b1a0 --- /dev/null +++ b/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 { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt new file mode 100644 index 00000000000..a6c9a0f5db9 --- /dev/null +++ b/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, 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 + 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 + get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } } + + override fun createPointer(): KtSymbolPointer = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt new file mode 100644 index 00000000000..35ba6379a25 --- /dev/null +++ b/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 + get() = withValidityAssertion { emptyList() } + + override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion { + return false + } + + override val annotationClassIds: Collection + get() = withValidityAssertion { emptyList() } + + override fun createPointer(): KtSymbolPointer = withValidityAssertion { + return KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt new file mode 100644 index 00000000000..baf7603860e --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt new file mode 100644 index 00000000000..8c4d8ded502 --- /dev/null +++ b/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 { + 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 + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt new file mode 100644 index 00000000000..bb3ea853bec --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt new file mode 100644 index 00000000000..adb93cbfff6 --- /dev/null +++ b/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 { + override val descriptor: FunctionDescriptor? by cached { + val bindingContext = analysisSession.analyze(psi) + bindingContext[BindingContext.FUNCTION, psi] + } + + override val valueParameters: List + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt new file mode 100644 index 00000000000..7006fd23ff3 --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt new file mode 100644 index 00000000000..189466791dd --- /dev/null +++ b/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 { + 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 + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt new file mode 100644 index 00000000000..789d6753a65 --- /dev/null +++ b/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 { + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt new file mode 100644 index 00000000000..3998b2d9cd9 --- /dev/null +++ b/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 { + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt new file mode 100644 index 00000000000..35f5ad902f0 --- /dev/null +++ b/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 { + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt new file mode 100644 index 00000000000..c85b8581636 --- /dev/null +++ b/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 { + 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 + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt new file mode 100644 index 00000000000..170fbce011b --- /dev/null +++ b/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 { + 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 = withValidityAssertion { + return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer() + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbol.kt new file mode 100644 index 00000000000..3f40061170f --- /dev/null +++ b/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

: 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 + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt new file mode 100644 index 00000000000..e1d7f344b85 --- /dev/null +++ b/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() + val className = mutableListOf() + + 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 + 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) +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt new file mode 100644 index 00000000000..b27b96a69f7 --- /dev/null +++ b/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 } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt new file mode 100644 index 00000000000..f3822758205 --- /dev/null +++ b/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 + get() = withValidityAssertion { emptyList() } + + override val nullability: KtTypeNullability + get() = withValidityAssertion { type.ktNullability } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt new file mode 100644 index 00000000000..b30fb4970dd --- /dev/null +++ b/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) } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt new file mode 100644 index 00000000000..13459e91c2f --- /dev/null +++ b/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 } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt new file mode 100644 index 00000000000..10797fbf8c3 --- /dev/null +++ b/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 + 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 + get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisSession) } } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt new file mode 100644 index 00000000000..be04e557039 --- /dev/null +++ b/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, + override val analysisSession: KtFe10AnalysisSession +) : KtIntersectionType(), KtFe10Type { + override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() } + + override val conjuncts: List by cached { + val result = ArrayList(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 } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt new file mode 100644 index 00000000000..d4387c9b20c --- /dev/null +++ b/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 } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.kt new file mode 100644 index 00000000000..b4e5d4939ac --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.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.types + +import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescTypeParameterSymbol +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.KtTypeParameterSymbol +import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability +import org.jetbrains.kotlin.analysis.api.types.KtTypeParameterType +import org.jetbrains.kotlin.analysis.api.withValidityAssertion +import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.SimpleType + +internal class KtFe10TypeParameterType( + override val type: SimpleType, + private val parameter: TypeParameterDescriptor, + override val analysisSession: KtFe10AnalysisSession +) : KtTypeParameterType(), KtFe10Type { + override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() } + + override val name: Name + get() = withValidityAssertion { parameter.name } + + override val nullability: KtTypeNullability + get() = withValidityAssertion { type.ktNullability } + + override val symbol: KtTypeParameterSymbol + get() = withValidityAssertion { KtFe10DescTypeParameterSymbol(parameter, analysisSession) } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.kt new file mode 100644 index 00000000000..52208cfb618 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.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.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.maybeLocalClassId +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.KtTypeNullability +import org.jetbrains.kotlin.analysis.api.types.KtUsualClassType +import org.jetbrains.kotlin.analysis.api.withValidityAssertion +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.types.SimpleType + +internal class KtFe10UsualClassType( + override val type: SimpleType, + private val descriptor: ClassDescriptor, + override val analysisSession: KtFe10AnalysisSession +) : KtUsualClassType(), KtFe10Type { + override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() } + + override val classId: ClassId + get() = withValidityAssertion { descriptor.maybeLocalClassId } + + override val classSymbol: KtClassLikeSymbol + get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisSession) } + + override val typeArguments: List + get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisSession) } } + + override val nullability: KtTypeNullability + get() = withValidityAssertion { type.ktNullability } + +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt new file mode 100644 index 00000000000..bac4dc91182 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.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.types.base + +import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner +import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions +import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession +import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer +import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.UnwrappedType + +interface KtFe10Type : ValidityTokenOwner { + val type: UnwrappedType + + val analysisSession: KtFe10AnalysisSession + + override val token: ValidityToken + get() = analysisSession.token +} + +internal fun KotlinType.asStringForDebugging(): String { + val builder = StringBuilder() + val renderer = KtFe10TypeRenderer(KtTypeRendererOptions.DEFAULT, isDebugText = true) + renderer.render(this, builder) + return builder.toString() +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10TypeAndAnnotations.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10TypeAndAnnotations.kt new file mode 100644 index 00000000000..810e77066f2 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10TypeAndAnnotations.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.base + +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescAnnotationCall +import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall +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.types.KotlinType + +internal class KtFe10TypeAndAnnotations( + override val type: KtType, + private val originalType: KotlinType, + override val token: ValidityToken +) : KtTypeAndAnnotations() { + override val annotations: List + get() = withValidityAssertion { + originalType.annotations.map { KtFe10DescAnnotationCall(it, token) } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10JvmTypeMapperContext.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10JvmTypeMapperContext.kt new file mode 100644 index 00000000000..4a6f07523f0 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10JvmTypeMapperContext.kt @@ -0,0 +1,182 @@ +/* + * 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.utils + +import org.jetbrains.kotlin.builtins.functions.BuiltInFunctionArity +import org.jetbrains.kotlin.builtins.isFunctionType +import org.jetbrains.kotlin.builtins.isKFunctionType +import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap +import org.jetbrains.kotlin.codegen.JvmCodegenUtil +import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter +import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper +import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.Companion.hasNothingInNonContravariantPosition +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.load.kotlin.TypeMappingMode +import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.types.* +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.TypeConstructorMarker +import org.jetbrains.org.objectweb.asm.Type + +internal class KtFe10JvmTypeMapperContext(private val resolveSession: ResolveSession) : TypeMappingContext { + companion object { + fun getNestedType(type: KotlinType): NestedType { + val possiblyInnerType = type.buildPossiblyInnerType() ?: throw IllegalArgumentException(type.toString()) + val innerTypesAsList = possiblyInnerType.segments() + val indexOfParameterizedType = innerTypesAsList.indexOfFirst { innerPart -> innerPart.arguments.isNotEmpty() } + + return if (indexOfParameterizedType < 0 || innerTypesAsList.size == 1) { + val classifier = type.constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters + ?: throw IllegalArgumentException(type.toString()) + + NestedType(PossiblyInnerType(classifier, type.arguments, null), emptyList()) + } else { + NestedType(innerTypesAsList[indexOfParameterizedType], innerTypesAsList.drop(indexOfParameterizedType + 1)) + } + } + } + + class NestedType(val root: PossiblyInnerType, val nested: List) + + override val typeContext = KtFe10TypeSystemCommonBackendContextForTypeMapping(resolveSession) + + fun mapType(type: KotlinType, mode: TypeMappingMode = TypeMappingMode.DEFAULT, sw: JvmSignatureWriter? = null): Type { + return AbstractTypeMapper.mapType(this, type, mode, sw) + } + + override fun getClassInternalName(typeConstructor: TypeConstructorMarker): String { + require(typeConstructor is TypeConstructor) + + return when (val declaration = typeConstructor.declarationDescriptor) { + is TypeParameterDescriptor -> declaration.name.asString().sanitize() + is TypeAliasDescriptor -> getClassInternalName(declaration.expandedType.constructor) + is ClassDescriptor -> computeNonLocalClassInternalName(declaration) ?: computeSupertypeInternalName(declaration) + else -> error("Unexpected declaration type: $declaration") + } + } + + private fun computeNonLocalClassInternalName(descriptor: ClassDescriptor): String? { + val selfName = descriptor.name.takeIf { !it.isSpecial } ?: return null + + return when (val parent = descriptor.containingDeclaration) { + is PackageFragmentDescriptor -> { + val packageInternalName = parent.fqName.asString().replace('.', '/') + "$packageInternalName/$selfName" + } + is ClassDescriptor -> { + val parentInternalName = computeNonLocalClassInternalName(parent) + if (parentInternalName != null) "$parentInternalName$$selfName" else null + } + else -> null + } + } + + private fun computeSupertypeInternalName(descriptor: ClassDescriptor): String { + var interfaceSupertypeInternalName: String? = null + + for (supertype in descriptor.typeConstructor.supertypes) { + val declaration = supertype.constructor.declarationDescriptor ?: continue + + if (declaration !is ClassDescriptor || declaration.name.isSpecial) { + continue + } + + if (declaration.kind != ClassKind.INTERFACE && declaration.kind != ClassKind.ANNOTATION_CLASS) { + val internalName = computeNonLocalClassInternalName(declaration) + if (internalName != null) { + return internalName + } + } else if (interfaceSupertypeInternalName == null) { + interfaceSupertypeInternalName = computeNonLocalClassInternalName(declaration) + } + } + + return interfaceSupertypeInternalName ?: "java/lang/Object" + } + + override fun getScriptInternalName(typeConstructor: TypeConstructorMarker): String { + return getClassInternalName(typeConstructor) + } + + override fun JvmSignatureWriter.writeGenericType(type: KotlinTypeMarker, asmType: Type, mode: TypeMappingMode) { + require(type is KotlinType) + + val typeDeclaration = type.constructor.declarationDescriptor + + val skipArguments = skipGenericSignature() + || typeContext.hasNothingInNonContravariantPosition(type) + || type.arguments.isEmpty() + || typeDeclaration == null + || ErrorUtils.isError(typeDeclaration) + + if (skipArguments) { + writeAsmType(asmType) + return + } + + val nestedType = getNestedType(type) + if (nestedType.nested.isEmpty()) { + writeClassBegin(asmType) + writeGenericArguments(this, nestedType.root, mode) + } else { + writeOuterClassBegin(asmType, mapType(nestedType.root.classDescriptor.defaultType).internalName) + writeGenericArguments(this, nestedType.root, mode) + writeInnerParts(nestedType.nested, this, mode, 0) + } + + writeClassEnd() + } + + private fun writeGenericArguments(sw: JvmSignatureWriter, type: PossiblyInnerType, mode: TypeMappingMode) { + val classifier = type.classifierDescriptor + val defaultType = classifier.defaultType + val parameters = classifier.declaredTypeParameters + val arguments = type.arguments + + if ((defaultType.isFunctionType && arguments.size > BuiltInFunctionArity.BIG_ARITY) || defaultType.isKFunctionType) { + writeGenericArguments(sw, arguments.take(1), parameters.take(1), mode) + return + } + + writeGenericArguments(sw, arguments, parameters, mode) + } + + private fun writeGenericArguments( + sw: JvmSignatureWriter, + arguments: List, + parameters: List, + mode: TypeMappingMode + ) { + with(KotlinTypeMapper) { + typeContext.writeGenericArguments(sw, arguments, parameters, mode) { type, sw, mode -> + mapType(type as KotlinType, mode, sw) + } + } + } + + private fun writeInnerParts(innerTypesAsList: List, sw: JvmSignatureWriter, mode: TypeMappingMode, index: Int) { + for (innerPart in innerTypesAsList.subList(index, innerTypesAsList.size)) { + sw.writeInnerClass(getJvmShortName(innerPart.classDescriptor)) + writeGenericArguments(sw, innerPart, mode) + } + } + + private fun getJvmShortName(declaration: ClassDescriptor): String { + if (!DescriptorUtils.isLocal(declaration)) { + val shortClassName = JavaToKotlinClassMap.mapKotlinToJava(declaration.fqNameUnsafe)?.shortClassName?.asString() + if (shortClassName != null) { + return shortClassName + } + } + + return SpecialNames.safeIdentifier(declaration.name).identifier + } + + private fun String.sanitize() = JvmCodegenUtil.sanitizeNameIfNeeded(this, resolveSession.languageVersionSettings) +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt new file mode 100644 index 00000000000..c6bf50f4d72 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt @@ -0,0 +1,658 @@ +/* + * 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.utils + +import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions +import org.jetbrains.kotlin.analysis.api.components.RendererModifier +import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.isExplicitOverride +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor +import org.jetbrains.kotlin.builtins.isFunctionType +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.name.StandardClassIds +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.renderer.render +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue +import org.jetbrains.kotlin.resolve.calls.components.isVararg +import org.jetbrains.kotlin.resolve.constants.* +import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny +import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces +import org.jetbrains.kotlin.resolve.source.getPsi +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.TypeApproximator +import org.jetbrains.kotlin.types.typeUtil.isNullableAny +import org.jetbrains.kotlin.types.typeUtil.isUnit +import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly + +internal typealias KtFe10RendererConsumer = StringBuilder + +internal class KtFe10Renderer( + private val analysisSession: KtFe10AnalysisSession, + private val options: KtDeclarationRendererOptions, + isDebugText: Boolean = false +) { + private companion object { + private val INDENTATION = " ".repeat(4) + + val IGNORED_VISIBILITIES: Set = setOf( + Visibilities.Local, + Visibilities.PrivateToThis, + Visibilities.InvisibleFake, + Visibilities.Inherited, + Visibilities.Unknown, + Visibilities.DEFAULT_VISIBILITY + ) + + val IGNORED_SUPERTYPES: Set = setOf( + StandardClassIds.Enum, + StandardClassIds.Annotation + ) + } + + private val typeRenderer = KtFe10TypeRenderer(options.typeRendererOptions, isDebugText) + + private val typeApproximator = TypeApproximator( + analysisSession.resolveSession.moduleDescriptor.builtIns, + analysisSession.resolveSession.languageVersionSettings + ) + + private var indentation = 0 + + private fun KtFe10RendererConsumer.curlyBlock(body: KtFe10RendererConsumer.() -> Unit) { + append(" {") + indentedBlock(body) + appendLine() + renderIndentation() + append('}') + } + + private fun KtFe10RendererConsumer.indentedBlock(body: KtFe10RendererConsumer.() -> Unit) { + indentation += 1 + body() + indentation -= 1 + } + + fun render(descriptor: DeclarationDescriptor, consumer: KtFe10RendererConsumer) { + consumer.renderDeclaration(descriptor) + } + + private fun KtFe10RendererConsumer.renderType(type: KotlinType, shouldApproximate: Boolean = false) { + if (shouldApproximate) { + val approximatedType = typeApproximator.approximateToSuperType(type.unwrap(), PublicApproximatorConfiguration) + ?: type.takeIf { it.constructor.declarationDescriptor?.name != SpecialNames.NO_NAME_PROVIDED } + ?: analysisSession.resolveSession.moduleDescriptor.builtIns.anyType + + renderType(approximatedType, shouldApproximate = false) + return + } + + renderAnnotations(type.annotations) { classId -> + !options.typeRendererOptions.renderFunctionType + || classId != StandardClassIds.Annotations.ExtensionFunctionType + } + + typeRenderer.render(type, this) + } + + private fun needsParenthesis(type: KotlinType): Boolean { + if (!type.annotations.isEmpty()) { + return true + } + + if (options.typeRendererOptions.renderFunctionType && type.isFunctionType) { + return true + } + + val descriptor = type.constructor.declarationDescriptor + if (descriptor is FunctionClassDescriptor && descriptor.functionKind.isSuspendType) { + return true + } + + return false + } + + private fun KtFe10RendererConsumer.renderDeclaration(descriptor: DeclarationDescriptor) { + when (descriptor) { + is ClassifierDescriptor -> renderClassifier(descriptor) + is CallableDescriptor -> renderCallable(descriptor) + else -> error("Unexpected descriptor kind: $descriptor") + } + } + + private fun KtFe10RendererConsumer.renderClassifier(descriptor: ClassifierDescriptor) { + when (descriptor) { + is TypeAliasDescriptor -> renderTypeAlias(descriptor) + is TypeParameterDescriptor -> renderTypeParameter(descriptor) + is ClassDescriptor -> renderClass(descriptor) + else -> error("Unexpected descriptor kind: $descriptor") + } + } + + private fun KtFe10RendererConsumer.renderTypeAlias(descriptor: TypeAliasDescriptor) { + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + renderModifiers(descriptor) + append("typealias ") + } + renderName(descriptor) + renderTypeParameters(descriptor.declaredTypeParameters) + append(" = ") + renderType(descriptor.expandedType) + } + + private fun KtFe10RendererConsumer.renderTypeParameters(typeParameters: List) { + renderList(typeParameters, separator = ", ", prefix = "<", postfix = ">", renderWhenEmpty = false) { renderTypeParameter(it) } + } + + private fun KtFe10RendererConsumer.renderTypeParameter(descriptor: TypeParameterDescriptor) { + renderModifier("reified", descriptor.isReified) + + val variance = descriptor.variance.label + renderModifier(variance, variance.isNotEmpty()) + + renderAnnotations(descriptor.annotations) + renderName(descriptor) + + val upperBounds = descriptor.upperBounds.filterNot { it.isNullableAny() } + renderList(upperBounds, separator = " & ", prefix = " : ", postfix = "", renderWhenEmpty = false) { renderType(it) } + } + + private fun KtFe10RendererConsumer.renderClass(descriptor: ClassDescriptor) { + appendLine() + renderIndentation() + + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + renderModifiers(descriptor) + + + if (DescriptorUtils.isAnonymousObject(descriptor)) { + append("object") + } else { + val classKeyword = when (descriptor.kind) { + ClassKind.CLASS -> "class" + ClassKind.INTERFACE -> "interface" + ClassKind.ENUM_CLASS -> "enum class" + ClassKind.ENUM_ENTRY -> "enum entry" + ClassKind.ANNOTATION_CLASS -> "annotation class" + ClassKind.OBJECT -> "object" + } + append(classKeyword) + } + } + + val shouldRenderName = !descriptor.name.isSpecial + && (!descriptor.isCompanionObject || descriptor.name != SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT) + + if (shouldRenderName) { + append(' ') + renderName(descriptor) + } + + renderTypeParameters(descriptor.declaredTypeParameters) + renderSupertypes(descriptor) + + if (options.renderContainingDeclarations) { + val (enumEntries, otherDeclarations) = descriptor.unsubstitutedMemberScope.getContributedDescriptors() + .filter { shouldRenderNestedDeclaration(descriptor, it) } + .partition { it is ClassDescriptor && it.kind == ClassKind.ENUM_ENTRY } + + val constructors = descriptor.constructors + .filter { shouldRenderNestedDeclaration(descriptor, it) } + + if (enumEntries.isNotEmpty() || otherDeclarations.isNotEmpty() || constructors.isNotEmpty()) { + curlyBlock { + enumEntries.forEach { renderEnumEntry(it as ClassDescriptor) } + sortDeclarations(constructors).forEach { renderConstructor(it) } + sortDeclarations(otherDeclarations).forEach { renderDeclaration(it) } + } + } + } + } + + private fun shouldRenderNestedDeclaration(owner: ClassDescriptor, declaration: DeclarationDescriptor): Boolean { + if (declaration is CallableMemberDescriptor && declaration.kind != CallableMemberDescriptor.Kind.DECLARATION) { + return false + } + + if ( + declaration is ConstructorDescriptor && !DescriptorUtils.isAnonymousObject(declaration.constructedClass) + && declaration.isPrimary && declaration.valueParameters.isEmpty() && declaration.annotations.isEmpty() + ) { + if (declaration.visibility == DescriptorVisibilities.DEFAULT_VISIBILITY) { + return false + } else if (owner.kind == ClassKind.OBJECT || owner.kind == ClassKind.ENUM_CLASS) { + return false + } + } + + if (declaration is FunctionDescriptor && owner.kind == ClassKind.ENUM_CLASS) { + if (declaration.name.asString() == "valueOf" && KotlinBuiltIns.isString(declaration.valueParameters.singleOrNull()?.type)) { + return false + } else if (declaration.name.asString() == "values" && declaration.valueParameters.isEmpty()) { + return false + } + } + + return true + } + + private fun sortDeclarations(declarations: List): List { + if (!options.sortNestedDeclarations) { + return declarations + } + + fun getDeclarationKind(declaration: DeclarationDescriptor): Int = when (declaration) { + is ConstructorDescriptor -> if (declaration.isPrimary) 1 else 2 + is PropertyDescriptor -> 3 + is FunctionDescriptor -> 4 + else -> 5 + } + + return declarations.sortedWith(Comparator { left, right -> + val kindResult = getDeclarationKind(left) - getDeclarationKind(right) + if (kindResult != 0) { + return@Comparator kindResult + } + + val nameResult = left.name.asString().compareTo(right.name.asString()) + if (nameResult != 0) { + return@Comparator nameResult + } + + val leftString = buildString { renderDeclaration(left) } + val rightString = buildString { renderDeclaration(right) } + return@Comparator leftString.compareTo(rightString) + }) + } + + private fun KtFe10RendererConsumer.renderSupertypes(descriptor: ClassDescriptor) { + val allowedSuperClasses = (listOfNotNull(descriptor.getSuperClassNotAny()) + descriptor.getSuperInterfaces()) + .filterTo(HashSet()) { it.classId !in IGNORED_SUPERTYPES } + + val supertypes = descriptor.typeConstructor.supertypes.filter { it.constructor.declarationDescriptor in allowedSuperClasses } + renderList(supertypes, separator = ", ", prefix = " : ", postfix = "", renderWhenEmpty = false) { renderType(it) } + } + + private fun KtFe10RendererConsumer.renderCallable(descriptor: CallableDescriptor) { + when (descriptor) { + is PropertyGetterDescriptor -> renderPropertyAccessor(descriptor) + is PropertySetterDescriptor -> renderPropertyAccessor(descriptor) + is PropertyDescriptor -> renderProperty(descriptor) + is ConstructorDescriptor -> renderConstructor(descriptor) + is FunctionDescriptor -> renderFunction(descriptor) + is ValueParameterDescriptor -> renderValueParameter(descriptor) + is LocalVariableDescriptor -> renderLocalVariable(descriptor) + else -> error("Unexpected descriptor kind: $descriptor") + } + } + + private fun KtFe10RendererConsumer.renderPropertyAccessor(descriptor: PropertyAccessorDescriptor) { + appendLine() + indentedBlock { + renderIndentation() + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + renderModifiers(descriptor) + } + + when (descriptor) { + is PropertyGetterDescriptor -> { + append("get()") + } + is PropertySetterDescriptor -> { + append("set(") + val valueParameter = descriptor.valueParameters.singleOrNull() + if (valueParameter != null) { + val name = valueParameter.name.takeIf { !it.isSpecial } ?: Name.identifier("value") + renderValueParameter(valueParameter, name) + } + append(")") + } + } + } + } + + private fun KtFe10RendererConsumer.renderEnumEntry(descriptor: ClassDescriptor) { + assert(descriptor.kind == ClassKind.ENUM_ENTRY) + + appendLine() + renderIndentation() + + renderName(descriptor) + append(',') + } + + private fun KtFe10RendererConsumer.renderLocalVariable(descriptor: LocalVariableDescriptor) { + appendLine() + renderIndentation() + + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + append(if (descriptor.isVar) "var" else "val").append(' ') + } + + renderName(descriptor) + append(": ") + renderType(descriptor.type, shouldApproximate = options.approximateTypes) + } + + private fun KtFe10RendererConsumer.renderProperty(descriptor: PropertyDescriptor) { + appendLine() + renderIndentation() + + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + renderModifiers(descriptor) + append(if (descriptor.isVar) "var" else "val").append(' ') + renderTypeParameters(descriptor.typeParameters) + if (descriptor.typeParameters.isNotEmpty()) { + append(' ') + } + } + + renderReceiver(descriptor) + renderName(descriptor) + append(": ") + renderType(descriptor.type, shouldApproximate = options.approximateTypes) + + if (options.renderContainingDeclarations) { + fun shouldRenderAccessor(accessor: PropertyAccessorDescriptor): Boolean { + return descriptor.isDelegated + || accessor.hasBody() + || !accessor.annotations.isEmpty() + || accessor.visibility != descriptor.visibility + } + + val getter = descriptor.getter + val setter = descriptor.setter + + val shouldRenderAccessors = (getter != null && shouldRenderAccessor(getter)) || (setter != null && shouldRenderAccessor(setter)) + if (shouldRenderAccessors) { + if (getter != null) { + renderPropertyAccessor(getter) + } + if (setter != null) { + renderPropertyAccessor(setter) + } + } + } + } + + private fun KtFe10RendererConsumer.renderReceiver(descriptor: CallableDescriptor) { + val extensionReceiver = descriptor.extensionReceiverParameter ?: return + val needsParentheses = !descriptor.annotations.isEmpty() || needsParenthesis(extensionReceiver.type) + if (needsParentheses) { + append('(') + } + renderType(extensionReceiver.type) + if (needsParentheses) { + append(')') + } + append('.') + } + + private fun KtFe10RendererConsumer.renderConstructor(descriptor: ConstructorDescriptor) { + appendLine() + renderIndentation() + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + } + append("constructor") + renderValueParameters(descriptor.valueParameters) + + renderLocalDeclarations(descriptor) + } + + private fun KtFe10RendererConsumer.renderFunction(descriptor: FunctionDescriptor) { + appendLine() + renderIndentation() + + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + renderModifiers(descriptor) + append("fun ") + renderTypeParameters(descriptor.typeParameters) + if (descriptor.typeParameters.isNotEmpty()) { + append(" ") + } + } + + renderReceiver(descriptor) + renderName(descriptor) + renderValueParameters(descriptor.valueParameters) + + val returnType = descriptor.returnType + if (returnType != null && !returnType.isUnit()) { + append(": ") + renderType(returnType, shouldApproximate = options.approximateTypes) + } + + renderLocalDeclarations(descriptor) + } + + private fun KtFe10RendererConsumer.renderValueParameters(valueParameters: List) { + renderList(valueParameters, separator = ", ", prefix = "(", postfix = ")", renderWhenEmpty = true) { renderValueParameter(it) } + } + + private fun KtFe10RendererConsumer.renderValueParameter(descriptor: ValueParameterDescriptor, name: Name = descriptor.name) { + if (options.renderDeclarationHeader) { + renderAnnotations(descriptor.annotations) + } + + renderModifiers(descriptor) + append(name.render()) + append(": ") + renderType(descriptor.varargElementType ?: descriptor.type) + + if (options.renderDefaultParameterValue && descriptor.hasDefaultValue()) { + append(" = ...") + } + } + + private fun KtFe10RendererConsumer.renderLocalDeclarations(descriptor: CallableMemberDescriptor) { + if (!options.renderContainingDeclarations) { + return + } + + val body = when (val declaration = descriptor.source.getPsi()) { + is KtFunction -> declaration.bodyExpression + is KtPropertyAccessor -> declaration.bodyExpression + else -> null + } + + val collectedChildren = mutableListOf() + + body?.accept(object : KtTreeVisitorVoid() { + override fun visitDeclaration(declaration: KtDeclaration) { + if (declaration is KtFunction || declaration is KtVariableDeclaration || declaration is KtClassOrObject) { + val bindingContext = analysisSession.analyze(declaration) + val childDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration] + if (childDescriptor != null) { + collectedChildren += childDescriptor + } + } else { + super.visitDeclaration(declaration) + } + } + }) + + if (collectedChildren.isNotEmpty()) { + curlyBlock { + collectedChildren.forEach { renderDeclaration(it) } + } + } + } + + private fun KtFe10RendererConsumer.renderName(descriptor: DeclarationDescriptor) { + append(descriptor.name.render()) + } + + private fun KtFe10RendererConsumer.renderAnnotations(annotations: Annotations, predicate: (ClassId) -> Boolean = { true }) { + if (RendererModifier.ANNOTATIONS !in options.modifiers) { + return + } + + for (annotation in annotations) { + val annotationClass = annotation.annotationClass ?: continue + + val classId = annotationClass.classId + if (classId != null && !predicate(classId)) { + continue + } + + if (annotationClass.fqNameSafe != StandardNames.FqNames.parameterName) { + append('@') + renderType(annotation.type) + + val valueArguments = annotation.allValueArguments.entries.sortedBy { it.key.asString() } + renderList(valueArguments, separator = ", ", prefix = "(", postfix = ")", renderWhenEmpty = false) { (name, value) -> + append(name.render()) + append(" = ") + when (value) { + is UByteValue -> append(value.value.toUByte().toString()) + is UShortValue -> append(value.value.toUShort().toString()) + is UIntValue -> append(value.value.toUInt().toString()) + is ULongValue -> append(value.value.toULong().toString()) + is EnumValue, is AnnotationValue, is KClassValue, is ArrayValue, is ErrorValue -> append("NOT_CONST_EXPRESSION") + else -> append(value.value) + } + } + + append(' ') + } + } + } + + private fun KtFe10RendererConsumer.renderModifiers(descriptor: DeclarationDescriptor) { + if (descriptor is MemberDescriptor) { + renderVisibility(descriptor) + } + + if (descriptor is PropertyDescriptor) { + renderModifier("const", descriptor.isConst, RendererModifier.CONST) + renderModifier("lateinit", descriptor.isLateInit, RendererModifier.LATEINIT) + } + + if (descriptor is ValueParameterDescriptor) { + renderModifier("crossinline", descriptor.isCrossinline) + renderModifier("noinline", descriptor.isNoinline) + } + + if (descriptor is MemberDescriptor) { + renderModifier("external", descriptor.isExternal) + renderModifier("expect", descriptor.isExpect, RendererModifier.EXPECT) + renderModifier("actual", descriptor.isActual, RendererModifier.ACTUAL) + renderModality(descriptor) + } + + if (descriptor is CallableMemberDescriptor) { + renderModifier("override", descriptor.isExplicitOverride, RendererModifier.OVERRIDE) + } + + if (descriptor is ValueParameterDescriptor) { + renderModifier("vararg", descriptor.isVararg) + } + + if (descriptor is FunctionDescriptor) { + renderModifier("tailrec", descriptor.isTailrec) + renderModifier("suspend", descriptor.isSuspend) + renderModifier("inline", descriptor.isInline, RendererModifier.INLINE) + renderModifier("infix", descriptor.isInfix) + renderModifier("operator", descriptor.isOperator, RendererModifier.OPERATOR) + } + + if (descriptor is ClassDescriptor) { + renderModifier("inner", descriptor.isInner, RendererModifier.INNER) + renderModifier("data", descriptor.isData, RendererModifier.DATA) + renderModifier("inline", descriptor.isInline, RendererModifier.INNER) + renderModifier("fun", descriptor.isFun, RendererModifier.FUN) + renderModifier("companion", descriptor.isCompanionObject) + } + } + + private fun KtFe10RendererConsumer.renderVisibility(descriptor: DeclarationDescriptorWithVisibility) { + val visibility = descriptor.ktVisibility + renderModifier(visibility.internalDisplayName, visibility !in IGNORED_VISIBILITIES, RendererModifier.VISIBILITY) + } + + private fun KtFe10RendererConsumer.renderModality(descriptor: MemberDescriptor) { + if (descriptor is PropertyAccessorDescriptor || (descriptor is CallableMemberDescriptor && descriptor.isExplicitOverride)) { + return + } + + renderModifier( + descriptor.modality.name.toLowerCaseAsciiOnly(), + descriptor.modality != getDefaultModality(descriptor), + RendererModifier.MODALITY + ) + } + + private fun getDefaultModality(descriptor: MemberDescriptor): Modality { + when (descriptor) { + is ClassDescriptor -> return if (descriptor.kind == ClassKind.INTERFACE) Modality.ABSTRACT else Modality.FINAL + is CallableMemberDescriptor -> { + val containingDeclaration = descriptor.containingDeclaration + if (containingDeclaration !is ClassDescriptor) { + return Modality.FINAL + } + if (descriptor.isExplicitOverride && containingDeclaration.modality != Modality.FINAL) { + return Modality.OPEN + } else if (containingDeclaration.kind == ClassKind.INTERFACE && descriptor.visibility != DescriptorVisibilities.PRIVATE) { + return if (descriptor.modality == Modality.ABSTRACT) Modality.ABSTRACT else Modality.OPEN + } + + return Modality.FINAL + } + else -> return Modality.FINAL + } + } + + private fun KtFe10RendererConsumer.renderModifier(text: String, state: Boolean, modifier: RendererModifier? = null) { + if (state && (modifier == null || modifier in options.modifiers)) { + append(text).append(' ') + } + } + + private fun KtFe10RendererConsumer.renderIndentation() { + append(INDENTATION.repeat(indentation)) + } +} + +internal fun KtFe10RendererConsumer.renderList( + list: Collection, + separator: String, + prefix: String = "", + postfix: String = "", + renderWhenEmpty: Boolean = true, + renderItem: KtFe10RendererConsumer.(T) -> Unit +) { + if (!renderWhenEmpty && list.isEmpty()) { + return + } + + append(prefix) + list.forEachIndexed { index, item -> + if (index > 0) { + append(separator) + } + renderItem(item) + } + append(postfix) +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt new file mode 100644 index 00000000000..ba14f0d2ec9 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt @@ -0,0 +1,182 @@ +/* + * 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.utils + +import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId +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.descriptors.ClassifierDescriptorWithTypeParameters +import org.jetbrains.kotlin.descriptors.PossiblyInnerType +import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.renderer.DescriptorRenderer +import org.jetbrains.kotlin.renderer.render +import org.jetbrains.kotlin.resolve.calls.inference.CapturedType +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.builtIns + +internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, private val isDebugText: Boolean = false) { + private companion object { + const val ERROR_TYPE_TEXT = "ERROR_TYPE" + } + + fun render(type: KotlinType, consumer: KtFe10RendererConsumer) { + consumer.renderType(type) + } + + private fun KtFe10RendererConsumer.renderType(type: KotlinType) { + when (val unwrappedType = type.unwrap()) { + is FlexibleType -> renderFlexibleType(unwrappedType) + is DefinitelyNotNullType -> renderDefinitelyNotNullType(unwrappedType) + is ErrorType -> renderErrorType() + is CapturedType -> renderCapturedType(unwrappedType) + is NewCapturedType -> renderCapturedType(unwrappedType) + is AbbreviatedType -> renderType(unwrappedType.abbreviation) + is SimpleType -> { + when (val typeConstructor = unwrappedType.constructor) { + is NewTypeVariableConstructor -> renderTypeVariableType(typeConstructor) + is IntersectionTypeConstructor -> renderIntersectionType(typeConstructor) + else -> { + val descriptor = unwrappedType.constructor.declarationDescriptor + if (!isDebugText && options.renderFunctionType && descriptor is FunctionClassDescriptor) { + renderFunctionType(unwrappedType) + } else if (descriptor is TypeParameterDescriptor) { + renderTypeParameterType(descriptor) + } else if (descriptor is ClassifierDescriptorWithTypeParameters) { + renderOrdinaryType(unwrappedType) + } else { + append("ERROR CLASS") + } + } + } + } + } + + if (type.isMarkedNullable) { + append("?") + } + } + + private fun KtFe10RendererConsumer.renderFlexibleType(type: FlexibleType) { + if (isDebugText) { + append("ft<") + renderType(type.lowerBound) + append(", ") + renderType(type.upperBound) + append(">") + return + } + + val lowerBoundText = buildString { renderType(type.lowerBound) } + val upperBoundText = buildString { renderType(type.upperBound) } + append(DescriptorRenderer.COMPACT.renderFlexibleType(lowerBoundText, upperBoundText, type.builtIns)) + } + + private fun KtFe10RendererConsumer.renderDefinitelyNotNullType(type: DefinitelyNotNullType) { + renderType(type.original) + append(" & Any") + } + + private fun KtFe10RendererConsumer.renderErrorType() { + append(ERROR_TYPE_TEXT) + } + + private fun KtFe10RendererConsumer.renderCapturedType(type: CapturedType) { + append("CapturedType(") + renderTypeProjection(type.typeProjection) + append(")") + } + + private fun KtFe10RendererConsumer.renderCapturedType(type: NewCapturedType) { + append("CapturedType(") + renderTypeProjection(type.constructor.projection) + append(")") + } + + private fun KtFe10RendererConsumer.renderTypeVariableType(typeConstructor: NewTypeVariableConstructor) { + val name = typeConstructor.originalTypeParameter?.name ?: SpecialNames.NO_NAME_PROVIDED + append("TypeVariable(").append(name.asString()).append(")") + } + + private fun KtFe10RendererConsumer.renderIntersectionType(typeConstructor: IntersectionTypeConstructor) { + if (isDebugText) { + append("it") + } + renderList(typeConstructor.supertypes, separator = " & ", prefix = "(", postfix = ")") { renderType(it) } + } + + private fun KtFe10RendererConsumer.renderFunctionType(type: SimpleType) { + val receiverType = type.getReceiverTypeFromFunctionType() + val valueParameters = type.getValueParameterTypesFromFunctionType() + val returnType = type.getReturnTypeFromFunctionType() + + if (receiverType != null) { + renderType(receiverType) + append(".") + } + renderList(valueParameters, separator = ", ", prefix = "(", postfix = ")") { renderTypeProjection(it) } + append(" -> ") + renderType(returnType) + } + + private fun KtFe10RendererConsumer.renderTypeParameterType(descriptor: TypeParameterDescriptor) { + append(descriptor.name.render()) + } + + private fun KtFe10RendererConsumer.renderOrdinaryType(type: SimpleType) { + val nestedType = KtFe10JvmTypeMapperContext.getNestedType(type) + renderTypeSegment(nestedType.root, isRoot = true) + renderList(nestedType.nested, separator = ".", prefix = ".", postfix = "", renderWhenEmpty = false) { renderTypeSegment(it) } + } + + private fun KtFe10RendererConsumer.renderTypeSegment(typeSegment: PossiblyInnerType, isRoot: Boolean = false) { + val classifier = typeSegment.classifierDescriptor + + if (isDebugText) { + append(classifier.maybeLocalClassId.asString()) + } else if (isRoot) { + val classId = classifier.maybeLocalClassId + if (!options.shortQualifiedNames && !classId.packageFqName.isRoot) { + renderFqName(classId.packageFqName) + append('.') + } + renderFqName(classId.relativeClassName) + } else { + append(classifier.name.render()) + } + + val arguments = typeSegment.arguments + renderList(arguments, separator = ", ", prefix = "<", postfix = ">", renderWhenEmpty = false) { renderTypeProjection(it) } + } + + private fun KtFe10RendererConsumer.renderFqName(fqName: FqName) { + renderList(fqName.pathSegments(), separator = ".") { append(it.render()) } + } + + private fun KtFe10RendererConsumer.renderTypeProjection(projection: TypeProjection) { + if (projection.isStarProjection) { + append("*") + } else { + when (projection.projectionKind) { + Variance.INVARIANT -> renderType(projection.type) + Variance.IN_VARIANCE -> { + append("in ") + renderType(projection.type) + } + Variance.OUT_VARIANCE -> { + append("out ") + renderType(projection.type) + } + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt new file mode 100644 index 00000000000..762496a0dc7 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt @@ -0,0 +1,107 @@ +/* + * 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.utils + +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.incremental.components.NoLookupLocation +import org.jetbrains.kotlin.name.StandardClassIds +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.types.* +import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContext +import org.jetbrains.kotlin.types.checker.NewTypeVariableConstructor +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.SimpleTypeMarker +import org.jetbrains.kotlin.types.model.TypeConstructorMarker +import org.jetbrains.kotlin.types.model.TypeParameterMarker + +internal class KtFe10TypeSystemCommonBackendContextForTypeMapping( + private val resolveSession: ResolveSession +) : TypeSystemCommonBackendContextForTypeMapping, ClassicTypeSystemContext { + override val builtIns: KotlinBuiltIns + get() = resolveSession.moduleDescriptor.builtIns + + override fun TypeConstructorMarker.isTypeParameter(): Boolean { + require(this is TypeConstructor) + return when (this) { + is NewTypeVariableConstructor -> true + else -> declarationDescriptor is TypeParameterDescriptor + } + } + + override fun TypeConstructorMarker.defaultType(): KotlinTypeMarker { + require(this is TypeConstructor) + val declaration = declarationDescriptor ?: return ErrorUtils.createErrorType("Unresolved declaration descriptor ($this)") + return declaration.defaultType + } + + override fun TypeConstructorMarker.isScript(): Boolean { + require(this is TypeConstructor) + return declarationDescriptor is ScriptDescriptor + } + + override fun SimpleTypeMarker.isSuspendFunction(): Boolean { + require(this is SimpleType) + val declaration = constructor.declarationDescriptor + return declaration is FunctionClassDescriptor && declaration.functionKind.isSuspendType + } + + override fun SimpleTypeMarker.isKClass(): Boolean { + require(this is SimpleType) + return constructor.declarationDescriptor == builtIns.kClass + } + + override fun KotlinTypeMarker.isRawType(): Boolean { + require(this is KotlinType) + return when (val declaration = constructor.declarationDescriptor) { + is ClassifierDescriptorWithTypeParameters -> declaration.declaredTypeParameters.isNotEmpty() && arguments.isEmpty() + else -> false + } + } + + override fun TypeConstructorMarker.typeWithArguments(arguments: List): SimpleTypeMarker { + require(this is TypeConstructor) + require(parameters.size == arguments.size) + + val declaration = declarationDescriptor + if (declaration == null) { + val errorArguments = arguments.map { TypeProjectionImpl(it as KotlinType) } + return ErrorUtils.createErrorTypeWithArguments("Unresolved type constructor $this", errorArguments) + } + + val substitutions = LinkedHashMap(parameters.size) + for (index in parameters.indices) { + val parameterTypeConstructor = parameters[index].typeConstructor + substitutions[parameterTypeConstructor] = TypeProjectionImpl(arguments[index] as KotlinType) + } + + return TypeSubstitutor.create(substitutions).substitute(declaration.defaultType, Variance.INVARIANT) as SimpleType + } + + override fun TypeParameterMarker.representativeUpperBound(): KotlinTypeMarker { + require(this is TypeParameterDescriptor) + + for (upperBound in upperBounds) { + val declaration = upperBound.constructor.declarationDescriptor as? ClassDescriptor ?: continue + if (declaration.kind != ClassKind.INTERFACE && declaration.kind != ClassKind.ANNOTATION_CLASS) { + return upperBound + } + } + + return upperBounds.firstOrNull() ?: builtIns.nullableAnyType + } + + override fun continuationTypeConstructor(): TypeConstructorMarker { + val continuationFqName = StandardClassIds.Continuation.asSingleFqName() + val foundClasses = resolveSession.getTopLevelClassifierDescriptors(continuationFqName, NoLookupLocation.FROM_IDE) + return foundClasses.firstOrNull()?.typeConstructor ?: ErrorUtils.createErrorTypeConstructor("Cannot find $continuationFqName") + } + + override fun functionNTypeConstructor(n: Int): TypeConstructorMarker { + return builtIns.getKFunction(n).typeConstructor + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/PublicApproximatorConfiguration.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/PublicApproximatorConfiguration.kt new file mode 100644 index 00000000000..fc5949a7e97 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/PublicApproximatorConfiguration.kt @@ -0,0 +1,18 @@ +/* + * 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.utils + +import org.jetbrains.kotlin.types.TypeApproximatorConfiguration + +@Suppress("SpellCheckingInspection") +internal object PublicApproximatorConfiguration : TypeApproximatorConfiguration.AllFlexibleSameValue() { + override val allFlexible: Boolean get() = false + override val errorType: Boolean get() = true + override val definitelyNotNullType: Boolean get() = false + override val integerLiteralType: Boolean get() = true + override val intersectionTypesInContravariantPositions: Boolean get() = true + override val localTypes: Boolean get() = true +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/ValidityAwareCachedValue.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/ValidityAwareCachedValue.kt new file mode 100644 index 00000000000..1be0e3b0279 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/ValidityAwareCachedValue.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.utils + +import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner +import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken +import org.jetbrains.kotlin.analysis.api.tokens.assertIsValidAndAccessible +import kotlin.properties.ReadOnlyProperty +import kotlin.reflect.KProperty + +/** + * Lazy value that guaranties safe publication and checks validity on every access + */ +internal class ValidityAwareCachedValue( + private val token: ValidityToken, + init: () -> T +) : ReadOnlyProperty { + private val lazyValue = lazy(LazyThreadSafetyMode.PUBLICATION, init) + + @Suppress("UNCHECKED_CAST") + override fun getValue(thisRef: Any, property: KProperty<*>): T { + token.assertIsValidAndAccessible() + return lazyValue.value + } +} + +internal fun ValidityTokenOwner.cached(init: () -> T) = ValidityAwareCachedValue(token, init) diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/AbstractKtFe10ReferenceResolveTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/AbstractKtFe10ReferenceResolveTest.kt new file mode 100644 index 00000000000..f7c6b7912cd --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/AbstractKtFe10ReferenceResolveTest.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.test + +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.AbstractReferenceResolveTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10ReferenceResolveTest : AbstractReferenceResolveTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + analyzeTestFiles(ktFiles, module, testServices) + super.doTestByFileStructure(ktFiles, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/AbstractKtFe10ResolveCallTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/AbstractKtFe10ResolveCallTest.kt new file mode 100644 index 00000000000..5bbd4a23d46 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/AbstractKtFe10ResolveCallTest.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.test + +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.fir.AbstractResolveCallTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10ResolveCallTest : AbstractResolveCallTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + analyzeTestFiles(ktFiles, module, testServices) + super.doTestByFileStructure(ktFiles, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10FrontendApiTestConfiguratorService.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10FrontendApiTestConfiguratorService.kt new file mode 100644 index 00000000000..c72b22ab517 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10FrontendApiTestConfiguratorService.kt @@ -0,0 +1,54 @@ +/* + * 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.test + +import com.intellij.mock.MockApplication +import com.intellij.mock.MockProject +import com.intellij.openapi.Disposable +import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession +import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider +import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisHandlerExtension +import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10CliAnalysisSessionProvider +import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10KotlinReferenceProviderContributor +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService +import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor +import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.extensions.AnalysisHandlerExtension +import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil +import org.jetbrains.kotlin.test.bind +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider + +object KtFe10FrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService { + override fun TestConfigurationBuilder.configureTest(disposable: Disposable) { + usePreAnalysisHandlers(::KtFe10ModuleRegistrarPreAnalysisHandler.bind(disposable)) + } + + @OptIn(InvalidWayOfUsingAnalysisSession::class) + override fun registerProjectServices(project: MockProject) { + project.registerService(KtAnalysisSessionProvider::class.java, KtFe10CliAnalysisSessionProvider(project)) + AnalysisHandlerExtension.registerExtension(project, KtFe10AnalysisHandlerExtension()) + } + + override fun registerApplicationServices(application: MockApplication) { + if (application.getServiceIfCreated(KotlinReferenceProvidersService::class.java) == null) { + application.registerService(KotlinReferenceProvidersService::class.java, HLApiReferenceProviderService::class.java) + application.registerService(KotlinReferenceProviderContributor::class.java, KtFe10KotlinReferenceProviderContributor::class.java) + } + } +} + +fun analyzeTestFiles(ktFiles: List, module: TestModule, testServices: TestServices) { + val compilerConfigurationProvider = testServices.compilerConfigurationProvider + val project = compilerConfigurationProvider.getProject(module) + val compilerConfiguration = compilerConfigurationProvider.getCompilerConfiguration(module) + val packageProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module) + JvmResolveUtil.analyze(project, ktFiles, compilerConfiguration, packageProviderFactory) +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10ModuleRegistrarPreAnalysisHandler.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10ModuleRegistrarPreAnalysisHandler.kt new file mode 100644 index 00000000000..b931f5588e2 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10ModuleRegistrarPreAnalysisHandler.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.test + +import com.intellij.mock.MockProject +import com.intellij.openapi.Disposable +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider +import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProviderFactory +import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory +import org.jetbrains.kotlin.analysis.providers.KotlinPackageProviderFactory +import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticDeclarationProviderFactory +import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticModificationTrackerFactory +import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticPackageProviderFactory +import org.jetbrains.kotlin.test.services.* + +class KtFe10ModuleRegistrarPreAnalysisHandler( + testServices: TestServices, + @Suppress("UNUSED_PARAMETER") parentDisposable: Disposable +) : PreAnalysisHandler(testServices) { + + private val moduleInfoProvider = testServices.projectModuleProvider + + override fun preprocessModuleStructure(moduleStructure: TestModuleStructure) { + // todo rework after all modules will have the same Project instance + val ktFilesByModule = moduleStructure.modules.associateWith { testModule -> + val project = testServices.compilerConfigurationProvider.getProject(testModule) + testServices.sourceFileProvider.getKtFilesForSourceFiles(testModule.files, project) + } + + val allKtFiles = ktFilesByModule.values.flatMap { it.values.toList() } + + ktFilesByModule.forEach { (testModule, ktFiles) -> + val project = testServices.compilerConfigurationProvider.getProject(testModule) + moduleInfoProvider.registerModuleInfo(project, testModule, ktFiles) + + with(project as MockProject) { + registerService(KotlinModificationTrackerFactory::class.java, KotlinStaticModificationTrackerFactory::class.java) + registerService(KotlinDeclarationProviderFactory::class.java, KotlinStaticDeclarationProviderFactory(allKtFiles)) + registerService(KotlinPackageProviderFactory::class.java, KotlinStaticPackageProviderFactory(allKtFiles)) + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10TestWithOutOfBlockModification.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10TestWithOutOfBlockModification.kt new file mode 100644 index 00000000000..b2bfbebb46a --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10TestWithOutOfBlockModification.kt @@ -0,0 +1,12 @@ +/* + * 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.test + +import org.jetbrains.kotlin.psi.KtFile + +object KtFe10TestWithOutOfBlockModification { + fun doOutOfBlockModification(@Suppress("UNUSED_PARAMETER") ktFile: KtFile) {} +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10ExpectedExpressionTypeTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10ExpectedExpressionTypeTest.kt new file mode 100644 index 00000000000..ac73a8553fa --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10ExpectedExpressionTypeTest.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.test.components + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractExpectedExpressionTypeTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10ExpectedExpressionTypeTest : AbstractExpectedExpressionTypeTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10HLExpressionTypeTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10HLExpressionTypeTest.kt new file mode 100644 index 00000000000..b36e3c7a7e0 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10HLExpressionTypeTest.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.test.components + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractHLExpressionTypeTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10HLExpressionTypeTest : AbstractHLExpressionTypeTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10HasCommonSubtypeTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10HasCommonSubtypeTest.kt new file mode 100644 index 00000000000..f775804c0c4 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10HasCommonSubtypeTest.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.test.components + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractHasCommonSubtypeTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10HasCommonSubtypeTest : AbstractHasCommonSubtypeTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10OverriddenDeclarationProviderTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10OverriddenDeclarationProviderTest.kt new file mode 100644 index 00000000000..74f6ad76e84 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10OverriddenDeclarationProviderTest.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.test.components + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractOverriddenDeclarationProviderTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10OverriddenDeclarationProviderTest : AbstractOverriddenDeclarationProviderTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + analyzeTestFiles(ktFiles, module, testServices) + super.doTestByFileStructure(ktFiles, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10RendererTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10RendererTest.kt new file mode 100644 index 00000000000..35196672e3e --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/AbstractKtFe10RendererTest.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.test.components + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractRendererTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10RendererTest : AbstractRendererTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10ExpectedExpressionTypeTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10ExpectedExpressionTypeTestGenerated.java new file mode 100644 index 00000000000..cd04f6075b7 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10ExpectedExpressionTypeTestGenerated.java @@ -0,0 +1,248 @@ +/* + * 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.test.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expectedExpressionType") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10ExpectedExpressionTypeTestGenerated extends AbstractKtFe10ExpectedExpressionTypeTest { + @Test + public void testAllFilesPresentInExpectedExpressionType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("functionExpressionBody.kt") + public void testFunctionExpressionBody() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionExpressionBody.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyBlockExpression.kt") + public void testFunctionExpressionBodyBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionExpressionBodyBlockExpression.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyQualified.kt") + public void testFunctionExpressionBodyQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionExpressionBodyQualified.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyWithTypeFromRHS.kt") + public void testFunctionExpressionBodyWithTypeFromRHS() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionExpressionBodyWithTypeFromRHS.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyWithoutExplicitType.kt") + public void testFunctionExpressionBodyWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionExpressionBodyWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("functionLambdaParam.kt") + public void testFunctionLambdaParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionLambdaParam.kt"); + } + + @Test + @TestMetadata("functionNamedlParam.kt") + public void testFunctionNamedlParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionNamedlParam.kt"); + } + + @Test + @TestMetadata("functionParamWithTypeParam.kt") + public void testFunctionParamWithTypeParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionParamWithTypeParam.kt"); + } + + @Test + @TestMetadata("functionPositionalParam.kt") + public void testFunctionPositionalParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionPositionalParam.kt"); + } + + @Test + @TestMetadata("functionPositionalParamQualified.kt") + public void testFunctionPositionalParamQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/functionPositionalParamQualified.kt"); + } + + @Test + @TestMetadata("ifCondition.kt") + public void testIfCondition() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/ifCondition.kt"); + } + + @Test + @TestMetadata("ifConditionQualified.kt") + public void testIfConditionQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/ifConditionQualified.kt"); + } + + @Test + @TestMetadata("infixFunctionAsRegularCallParam.kt") + public void testInfixFunctionAsRegularCallParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/infixFunctionAsRegularCallParam.kt"); + } + + @Test + @TestMetadata("infixFunctionParam.kt") + public void testInfixFunctionParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/infixFunctionParam.kt"); + } + + @Test + @TestMetadata("infixFunctionParamQualified.kt") + public void testInfixFunctionParamQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/infixFunctionParamQualified.kt"); + } + + @Test + @TestMetadata("lambdaWithExplicitTypeFromVariable.kt") + public void testLambdaWithExplicitTypeFromVariable() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/lambdaWithExplicitTypeFromVariable.kt"); + } + + @Test + @TestMetadata("lambdaWithoutReturnNorExplicitType.kt") + public void testLambdaWithoutReturnNorExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/lambdaWithoutReturnNorExplicitType.kt"); + } + + @Test + @TestMetadata("propertyDeclaration.kt") + public void testPropertyDeclaration() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/propertyDeclaration.kt"); + } + + @Test + @TestMetadata("propertyDeclarationQualified.kt") + public void testPropertyDeclarationQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/propertyDeclarationQualified.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithSafeCast.kt") + public void testPropertyDeclarationWithSafeCast() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/propertyDeclarationWithSafeCast.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithTypeCast.kt") + public void testPropertyDeclarationWithTypeCast() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/propertyDeclarationWithTypeCast.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithTypeFromRHS.kt") + public void testPropertyDeclarationWithTypeFromRHS() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/propertyDeclarationWithTypeFromRHS.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithoutExplicitType.kt") + public void testPropertyDeclarationWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/propertyDeclarationWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("returnFromFunction.kt") + public void testReturnFromFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/returnFromFunction.kt"); + } + + @Test + @TestMetadata("returnFromFunctionQualifiedReceiver.kt") + public void testReturnFromFunctionQualifiedReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt"); + } + + @Test + @TestMetadata("returnFromFunctionQualifiedSelector.kt") + public void testReturnFromFunctionQualifiedSelector() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/returnFromFunctionQualifiedSelector.kt"); + } + + @Test + @TestMetadata("returnFromLambda.kt") + public void testReturnFromLambda() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/returnFromLambda.kt"); + } + + @Test + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/sam.kt"); + } + + @Test + @TestMetadata("samAsArgument.kt") + public void testSamAsArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/samAsArgument.kt"); + } + + @Test + @TestMetadata("samAsConstructorArgument.kt") + public void testSamAsConstructorArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/samAsConstructorArgument.kt"); + } + + @Test + @TestMetadata("samAsReturn.kt") + public void testSamAsReturn() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/samAsReturn.kt"); + } + + @Test + @TestMetadata("samWithExplicitTypeFromProperty.kt") + public void testSamWithExplicitTypeFromProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/samWithExplicitTypeFromProperty.kt"); + } + + @Test + @TestMetadata("samWithTypeCast.kt") + public void testSamWithTypeCast() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/samWithTypeCast.kt"); + } + + @Test + @TestMetadata("variableAssignment.kt") + public void testVariableAssignment() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/variableAssignment.kt"); + } + + @Test + @TestMetadata("variableAssignmentQualified.kt") + public void testVariableAssignmentQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/variableAssignmentQualified.kt"); + } + + @Test + @TestMetadata("whileCondition.kt") + public void testWhileCondition() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/whileCondition.kt"); + } + + @Test + @TestMetadata("whileConditionQualified.kt") + public void testWhileConditionQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expectedExpressionType/whileConditionQualified.kt"); + } +} diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10HLExpressionTypeTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10HLExpressionTypeTestGenerated.java new file mode 100644 index 00000000000..5c0afbb9eea --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10HLExpressionTypeTestGenerated.java @@ -0,0 +1,134 @@ +/* + * 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.test.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expressionType") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10HLExpressionTypeTestGenerated extends AbstractKtFe10HLExpressionTypeTest { + @Test + public void testAllFilesPresentInExpressionType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("assignmentExpressionTarget.kt") + public void testAssignmentExpressionTarget() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/assignmentExpressionTarget.kt"); + } + + @Test + @TestMetadata("binaryExpression.kt") + public void testBinaryExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/binaryExpression.kt"); + } + + @Test + @TestMetadata("breakExpression.kt") + public void testBreakExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/breakExpression.kt"); + } + + @Test + @TestMetadata("forExpression.kt") + public void testForExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/forExpression.kt"); + } + + @Test + @TestMetadata("functionCall.kt") + public void testFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/functionCall.kt"); + } + + @Test + @TestMetadata("inParens.kt") + public void testInParens() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/inParens.kt"); + } + + @Test + @TestMetadata("insideStringTemplate.kt") + public void testInsideStringTemplate() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/insideStringTemplate.kt"); + } + + @Test + @TestMetadata("insideStringTemplateWithBinrary.kt") + public void testInsideStringTemplateWithBinrary() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/insideStringTemplateWithBinrary.kt"); + } + + @Test + @TestMetadata("intLiteral.kt") + public void testIntLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/intLiteral.kt"); + } + + @Test + @TestMetadata("nonExpression.kt") + public void testNonExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/nonExpression.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/property.kt"); + } + + @Test + @TestMetadata("resolvedSuper.kt") + public void testResolvedSuper() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/resolvedSuper.kt"); + } + + @Test + @TestMetadata("returnExpression.kt") + public void testReturnExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/returnExpression.kt"); + } + + @Test + @TestMetadata("stringLiteral.kt") + public void testStringLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/stringLiteral.kt"); + } + + @Test + @TestMetadata("unresolvedSuper_multipleSuperTypes.kt") + public void testUnresolvedSuper_multipleSuperTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/unresolvedSuper_multipleSuperTypes.kt"); + } + + @Test + @TestMetadata("unresolvedSuper_noSuperType.kt") + public void testUnresolvedSuper_noSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/unresolvedSuper_noSuperType.kt"); + } + + @Test + @TestMetadata("unresolvedSuper_singleSuperType.kt") + public void testUnresolvedSuper_singleSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/unresolvedSuper_singleSuperType.kt"); + } + + @Test + @TestMetadata("whileExpression.kt") + public void testWhileExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionType/whileExpression.kt"); + } +} diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10HasCommonSubtypeTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10HasCommonSubtypeTestGenerated.java new file mode 100644 index 00000000000..e106f7297f3 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10HasCommonSubtypeTestGenerated.java @@ -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.test.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/hasCommonSubtype") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10HasCommonSubtypeTestGenerated extends AbstractKtFe10HasCommonSubtypeTest { + @Test + public void testAllFilesPresentInHasCommonSubtype() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/hasCommonSubtype"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("collections.kt") + public void testCollections() throws Exception { + runTest("analysis/analysis-api/testData/components/hasCommonSubtype/collections.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("analysis/analysis-api/testData/components/hasCommonSubtype/dataClasses.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("analysis/analysis-api/testData/components/hasCommonSubtype/enums.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("analysis/analysis-api/testData/components/hasCommonSubtype/simple.kt"); + } +} diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10OverriddenDeclarationProviderTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10OverriddenDeclarationProviderTestGenerated.java new file mode 100644 index 00000000000..4ab1d6c7d89 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10OverriddenDeclarationProviderTestGenerated.java @@ -0,0 +1,86 @@ +/* + * 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.test.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/overridenDeclarations") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10OverriddenDeclarationProviderTestGenerated extends AbstractKtFe10OverriddenDeclarationProviderTest { + @Test + public void testAllFilesPresentInOverridenDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/overridenDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/backingField.kt"); + } + + @Test + @TestMetadata("inAnonymousClass.kt") + public void testInAnonymousClass() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/inAnonymousClass.kt"); + } + + @Test + @TestMetadata("inLocalClass.kt") + public void testInLocalClass() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/inLocalClass.kt"); + } + + @Test + @TestMetadata("inOtherFile.kt") + public void testInOtherFile() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/inOtherFile.kt"); + } + + @Test + @TestMetadata("intersectionOverride.kt") + public void testIntersectionOverride() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/intersectionOverride.kt"); + } + + @Test + @TestMetadata("intersectionOverride2.kt") + public void testIntersectionOverride2() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/intersectionOverride2.kt"); + } + + @Test + @TestMetadata("javaAccessors.kt") + public void testJavaAccessors() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/javaAccessors.kt"); + } + + @Test + @TestMetadata("multipleInterfaces.kt") + public void testMultipleInterfaces() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/multipleInterfaces.kt"); + } + + @Test + @TestMetadata("onEnumEntry.kt") + public void testOnEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/onEnumEntry.kt"); + } + + @Test + @TestMetadata("sequenceOfOverrides.kt") + public void testSequenceOfOverrides() throws Exception { + runTest("analysis/analysis-api/testData/components/overridenDeclarations/sequenceOfOverrides.kt"); + } +} diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10RendererTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10RendererTestGenerated.java new file mode 100644 index 00000000000..a899f41549b --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/KtFe10RendererTestGenerated.java @@ -0,0 +1,188 @@ +/* + * 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.test.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/declarationRenderer") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10RendererTestGenerated extends AbstractKtFe10RendererTest { + @Test + public void testAllFilesPresentInDeclarationRenderer() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/declarationRenderer"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotation.kt") + public void testAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/annotation.kt"); + } + + @Test + @TestMetadata("complexTypes.kt") + public void testComplexTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/complexTypes.kt"); + } + + @Test + @TestMetadata("constructorInObject.kt") + public void testConstructorInObject() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/constructorInObject.kt"); + } + + @Test + @TestMetadata("constructorOfAnonymousObject.kt") + public void testConstructorOfAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/constructorOfAnonymousObject.kt"); + } + + @Test + @TestMetadata("delegates.kt") + public void testDelegates() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/delegates.kt"); + } + + @Test + @TestMetadata("derivedClass.kt") + public void testDerivedClass() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/derivedClass.kt"); + } + + @Test + @TestMetadata("emptyAnonymousObject.kt") + public void testEmptyAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/emptyAnonymousObject.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/enums.kt"); + } + + @Test + @TestMetadata("enums2.kt") + public void testEnums2() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/enums2.kt"); + } + + @Test + @TestMetadata("expectActual.kt") + public void testExpectActual() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/expectActual.kt"); + } + + @Test + @TestMetadata("F.kt") + public void testF() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/F.kt"); + } + + @Test + @TestMetadata("functionTypes.kt") + public void testFunctionTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/functionTypes.kt"); + } + + @Test + @TestMetadata("genericFunctions.kt") + public void testGenericFunctions() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/genericFunctions.kt"); + } + + @Test + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/genericProperty.kt"); + } + + @Test + @TestMetadata("intersectionType.kt") + public void testIntersectionType() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/intersectionType.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/nestedClass.kt"); + } + + @Test + @TestMetadata("NestedOfAliasedType.kt") + public void testNestedOfAliasedType() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/NestedOfAliasedType.kt"); + } + + @Test + @TestMetadata("NestedSuperType.kt") + public void testNestedSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/NestedSuperType.kt"); + } + + @Test + @TestMetadata("noPrimaryConstructor.kt") + public void testNoPrimaryConstructor() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/noPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/simpleClass.kt"); + } + + @Test + @TestMetadata("simpleFun.kt") + public void testSimpleFun() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/simpleFun.kt"); + } + + @Test + @TestMetadata("simpleTypeAlias.kt") + public void testSimpleTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/simpleTypeAlias.kt"); + } + + @Test + @TestMetadata("typeAliasWithGeneric.kt") + public void testTypeAliasWithGeneric() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/typeAliasWithGeneric.kt"); + } + + @Test + @TestMetadata("typeParameterVsNested.kt") + public void testTypeParameterVsNested() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/typeParameterVsNested.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/typeParameters.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/vararg.kt"); + } + + @Test + @TestMetadata("where.kt") + public void testWhere() throws Exception { + runTest("analysis/analysis-api/testData/components/declarationRenderer/where.kt"); + } +} diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/scopes/AbstractKtFe10FileScopeTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/scopes/AbstractKtFe10FileScopeTest.kt new file mode 100644 index 00000000000..1575dc209ef --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/scopes/AbstractKtFe10FileScopeTest.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.test.scopes + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractFileScopeTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10FileScopeTest : AbstractFileScopeTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/scopes/AbstractKtFe10MemberScopeByFqNameTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/scopes/AbstractKtFe10MemberScopeByFqNameTest.kt new file mode 100644 index 00000000000..a6084304a9a --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/scopes/AbstractKtFe10MemberScopeByFqNameTest.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.test.scopes + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10TestWithOutOfBlockModification +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractMemberScopeByFqNameTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10MemberScopeByFqNameTest : AbstractMemberScopeByFqNameTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } + + override fun doOutOfBlockModification(ktFile: KtFile) { + KtFe10TestWithOutOfBlockModification.doOutOfBlockModification(ktFile) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10CompileTimeConstantEvaluatorTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10CompileTimeConstantEvaluatorTest.kt new file mode 100644 index 00000000000..6c94261c8c6 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10CompileTimeConstantEvaluatorTest.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.test.symbols + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractCompileTimeConstantEvaluatorTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10CompileTimeConstantEvaluatorTest : AbstractCompileTimeConstantEvaluatorTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByFqNameTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByFqNameTest.kt new file mode 100644 index 00000000000..514fe5353b9 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByFqNameTest.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.test.symbols + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10TestWithOutOfBlockModification +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByFqNameTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10SymbolByFqNameTest : AbstractSymbolByFqNameTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } + + override fun doOutOfBlockModification(ktFile: KtFile) { + KtFe10TestWithOutOfBlockModification.doOutOfBlockModification(ktFile) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByPsiTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByPsiTest.kt new file mode 100644 index 00000000000..497a14632bd --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByPsiTest.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.test.symbols + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10TestWithOutOfBlockModification +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByPsiTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10SymbolByPsiTest : AbstractSymbolByPsiTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } + + override fun doOutOfBlockModification(ktFile: KtFile) { + KtFe10TestWithOutOfBlockModification.doOutOfBlockModification(ktFile) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByReferenceTest.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByReferenceTest.kt new file mode 100644 index 00000000000..627e5455929 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/AbstractKtFe10SymbolByReferenceTest.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.test.symbols + +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10TestWithOutOfBlockModification +import org.jetbrains.kotlin.analysis.api.descriptors.test.analyzeTestFiles +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByReferenceTest +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractKtFe10SymbolByReferenceTest : AbstractSymbolByReferenceTest() { + override val testPrefix: String? + get() = "descriptors" + + override val configurator: FrontendApiTestConfiguratorService + get() = KtFe10FrontendApiTestConfiguratorService + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + analyzeTestFiles(listOf(ktFile), module, testServices) + super.doTestByFileStructure(ktFile, module, testServices) + } + + override fun doOutOfBlockModification(ktFile: KtFile) { + KtFe10TestWithOutOfBlockModification.doOutOfBlockModification(ktFile) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/KtFe10SymbolByFqNameTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/KtFe10SymbolByFqNameTestGenerated.java new file mode 100644 index 00000000000..6020616a912 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/KtFe10SymbolByFqNameTestGenerated.java @@ -0,0 +1,80 @@ +/* + * 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.test.symbols; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/symbols/symbolByFqName") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10SymbolByFqNameTestGenerated extends AbstractKtFe10SymbolByFqNameTest { + @Test + public void testAllFilesPresentInSymbolByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByFqName"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/class.kt"); + } + + @Test + @TestMetadata("classFromJdk.kt") + public void testClassFromJdk() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/classFromJdk.kt"); + } + + @Test + @TestMetadata("enumEntry.kt") + public void testEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/enumEntry.kt"); + } + + @Test + @TestMetadata("fileWalkDirectionEnum.kt") + public void testFileWalkDirectionEnum() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/fileWalkDirectionEnum.kt"); + } + + @Test + @TestMetadata("iterator.kt") + public void testIterator() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/iterator.kt"); + } + + @Test + @TestMetadata("listOf.kt") + public void testListOf() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/listOf.kt"); + } + + @Test + @TestMetadata("memberFunction.kt") + public void testMemberFunction() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/memberFunction.kt"); + } + + @Test + @TestMetadata("memberFunctionWithOverloads.kt") + public void testMemberFunctionWithOverloads() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/memberFunctionWithOverloads.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/nestedClass.kt"); + } +} diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/KtFe10SymbolByReferenceTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/KtFe10SymbolByReferenceTestGenerated.java new file mode 100644 index 00000000000..113e118bfbe --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/symbols/KtFe10SymbolByReferenceTestGenerated.java @@ -0,0 +1,44 @@ +/* + * 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.test.symbols; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/symbols/symbolByReference") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10SymbolByReferenceTestGenerated extends AbstractKtFe10SymbolByReferenceTest { + @Test + @TestMetadata("accessorField.kt") + public void testAccessorField() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/accessorField.kt"); + } + + @Test + public void testAllFilesPresentInSymbolByReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("constructorViaTypeAlias.kt") + public void testConstructorViaTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/constructorViaTypeAlias.kt"); + } + + @Test + @TestMetadata("samConstructor.kt") + public void testSamConstructor() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/samConstructor.kt"); + } +} diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt index a30655e8425..69fc58e29c1 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.analysis.api.fir.components import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.calls.* -import org.jetbrains.kotlin.analysis.api.components.KtCallResolver import org.jetbrains.kotlin.analysis.api.diagnostics.KtNonBoundToPsiErrorDiagnostic import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.buildSymbol @@ -17,13 +16,13 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirArrayOfSymbolProvider. import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirArrayOfSymbolProvider.arrayOfSymbol import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirArrayOfSymbolProvider.arrayTypeToArrayOfCall import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFunctionSymbol +import org.jetbrains.kotlin.analysis.api.impl.base.components.AbstractKtCallResolver import org.jetbrains.kotlin.analysis.api.symbols.* import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers 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.analysis.low.level.api.fir.api.getOrBuildFir -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic import org.jetbrains.kotlin.fir.declarations.FirConstructor @@ -41,17 +40,15 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.idea.references.FirReferenceResolveHelper import org.jetbrains.kotlin.idea.references.readWriteAccessWithFullExpressionWithPossibleResolve -import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.findAssignment -import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.addToStdlib.safeAs import java.util.concurrent.ConcurrentHashMap internal class KtFirCallResolver( override val analysisSession: KtFirAnalysisSession, override val token: ValidityToken, -) : KtCallResolver(), KtFirAnalysisSessionComponent { +) : AbstractKtCallResolver(), KtFirAnalysisSessionComponent { private val diagnosticCache = mutableListOf() private val cache: ConcurrentHashMap = ConcurrentHashMap() @@ -361,13 +358,4 @@ internal class KtFirCallResolver( private fun KtAnalysisSession.getPrimaryConstructor(symbolWithMembers: KtSymbolWithMembers): KtConstructorSymbol? = symbolWithMembers.getDeclaredMemberScope().getConstructors().firstOrNull { it.isPrimary } - - companion object { - private val kotlinFunctionInvokeCallableIds = (0..23).flatMapTo(hashSetOf()) { arity -> - listOf( - CallableId(StandardNames.getFunctionClassId(arity), OperatorNameConventions.INVOKE), - CallableId(StandardNames.getSuspendFunctionClassId(arity), OperatorNameConventions.INVOKE) - ) - } - } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt index 63292a8db33..13ddd7191a1 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.analysis.api.fir.scopes.* import org.jetbrains.kotlin.analysis.api.fir.symbols.* import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef +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 @@ -122,7 +123,7 @@ internal class KtFirScopeProvider( override fun getCompositeScope(subScopes: List): KtCompositeScope = withValidityAssertion { - KtFirCompositeScope(subScopes, token) + SimpleKtCompositeScope(subScopes, token) } override fun getTypeScope(type: KtType): KtScope? { diff --git a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractCompilerBasedTest.kt b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractCompilerBasedTest.kt index 9423664cfe7..cac0c33967f 100644 --- a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractCompilerBasedTest.kt +++ b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractCompilerBasedTest.kt @@ -19,7 +19,7 @@ abstract class AbstractCompilerBasedTest : AbstractKotlinCompilerTest() { protected val disposable: Disposable get() = _disposable!! @BeforeEach - private fun intiDisposable(testInfo: TestInfo) { + private fun initDisposable(testInfo: TestInfo) { _disposable = Disposer.newDisposable("disposable for ${testInfo.displayName}") } diff --git a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestWithDisposable.kt b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestWithDisposable.kt index 155608629c2..422fd6e90a3 100644 --- a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestWithDisposable.kt +++ b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestWithDisposable.kt @@ -16,7 +16,7 @@ abstract class TestWithDisposable { protected val disposable: Disposable get() = _disposable!! @BeforeEach - private fun intiDisposable(testInfo: TestInfo) { + private fun initDisposable(testInfo: TestInfo) { _disposable = Disposer.newDisposable("disposable for ${testInfo.displayName}") } diff --git a/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/AbstractKtCallResolver.kt b/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/AbstractKtCallResolver.kt new file mode 100644 index 00000000000..a4cb58b2be4 --- /dev/null +++ b/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/AbstractKtCallResolver.kt @@ -0,0 +1,22 @@ +/* + * 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.impl.base.components + +import org.jetbrains.kotlin.analysis.api.components.KtCallResolver +import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.name.CallableId +import org.jetbrains.kotlin.util.OperatorNameConventions + +abstract class AbstractKtCallResolver : KtCallResolver() { + protected companion object { + val kotlinFunctionInvokeCallableIds = (0..23).flatMapTo(hashSetOf()) { arity -> + listOf( + CallableId(StandardNames.getFunctionClassId(arity), OperatorNameConventions.INVOKE), + CallableId(StandardNames.getSuspendFunctionClassId(arity), OperatorNameConventions.INVOKE) + ) + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirCompositeScope.kt b/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/scopes/SimpleKtCompositeScope.kt similarity index 93% rename from analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirCompositeScope.kt rename to analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/scopes/SimpleKtCompositeScope.kt index 77473708e6b..f15632cf4a4 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirCompositeScope.kt +++ b/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/scopes/SimpleKtCompositeScope.kt @@ -1,12 +1,11 @@ /* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * 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.fir.scopes +package org.jetbrains.kotlin.analysis.api.impl.base.scopes import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner -import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.scopes.KtCompositeScope import org.jetbrains.kotlin.analysis.api.scopes.KtScope import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter @@ -14,13 +13,12 @@ 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 - -// todo do we need caches here? @OptIn(ExperimentalStdlibApi::class) -class KtFirCompositeScope( +class SimpleKtCompositeScope( override val subScopes: List, override val token: ValidityToken ) : KtCompositeScope, ValidityTokenOwner { diff --git a/build.gradle.kts b/build.gradle.kts index 2f8855bf8e7..78fa9898767 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -320,6 +320,8 @@ extra["compilerArtifactsForIde"] = listOf( ":prepare:ide-plugin-dependencies:high-level-api-for-ide", ":prepare:ide-plugin-dependencies:high-level-api-fir-for-ide", ":prepare:ide-plugin-dependencies:high-level-api-fir-tests-for-ide", + ":prepare:ide-plugin-dependencies:high-level-api-fe10-for-ide", + ":prepare:ide-plugin-dependencies:high-level-api-fe10-tests-for-ide", ":prepare:ide-plugin-dependencies:analysis-api-providers-for-ide", ":prepare:ide-plugin-dependencies:analysis-project-structure-for-ide", ":prepare:ide-plugin-dependencies:symbol-light-classes-for-ide", @@ -874,6 +876,7 @@ tasks { dependsOn( ":analysis:analysis-api:test", ":analysis:analysis-api-fir:test", + ":analysis:analysis-api-fe10:test", ":analysis:low-level-api-fir:test" ) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt index 2b17932bc24..e98c1820be3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt @@ -19,25 +19,23 @@ package org.jetbrains.kotlin.descriptors.impl import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.psi.KtProperty -import org.jetbrains.kotlin.resolve.source.toSourceElement class SyntheticFieldDescriptor private constructor( val propertyDescriptor: PropertyDescriptor, accessorDescriptor: PropertyAccessorDescriptor, - property: KtProperty + sourceElement: SourceElement ) : LocalVariableDescriptor( accessorDescriptor, Annotations.EMPTY, SyntheticFieldDescriptor.NAME, propertyDescriptor.type, propertyDescriptor.isVar, false, false, - property.toSourceElement() + sourceElement ) { - constructor( accessorDescriptor: PropertyAccessorDescriptor, - property: KtProperty - ) : this(accessorDescriptor.correspondingProperty, accessorDescriptor, property) + sourceElement: SourceElement + ) : this(accessorDescriptor.correspondingProperty, accessorDescriptor, sourceElement) override fun getDispatchReceiverParameter() = null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 22cb52c9847..b647f0fba41 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -45,6 +45,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil; import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver; import org.jetbrains.kotlin.resolve.scopes.*; +import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt; import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; @@ -1013,7 +1014,8 @@ public class BodyResolver { if (functionDescriptor instanceof PropertyAccessorDescriptor && functionDescriptor.getExtensionReceiverParameter() == null) { PropertyAccessorDescriptor accessorDescriptor = (PropertyAccessorDescriptor) functionDescriptor; KtProperty property = (KtProperty) function.getParent(); - SyntheticFieldDescriptor fieldDescriptor = new SyntheticFieldDescriptor(accessorDescriptor, property); + SourceElement propertySourceElement = KotlinSourceElementKt.toSourceElement(property); + SyntheticFieldDescriptor fieldDescriptor = new SyntheticFieldDescriptor(accessorDescriptor, propertySourceElement); innerScope = new LexicalScopeImpl(innerScope, functionDescriptor, true, null, LexicalScopeKind.PROPERTY_ACCESSOR_BODY, LocalRedeclarationChecker.DO_NOTHING.INSTANCE, handler -> { diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiUtil.java b/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiUtil.java index 6fa83b9d7c1..bb1ef8f49d7 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiUtil.java +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiUtil.java @@ -591,6 +591,10 @@ public class KtPsiUtil { ((KtBinaryExpression) element).getOperationToken().equals(KtTokens.EQ); } + public static boolean isCast(@NotNull KtBinaryExpressionWithTypeRHS expression) { + return isSafeCast(expression) || isUnsafeCast(expression); + } + public static boolean isSafeCast(@NotNull KtBinaryExpressionWithTypeRHS expression) { return expression.getOperationReference().getReferencedNameElementType() == KtTokens.AS_SAFE; } diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.kt index b49b6d945e9..b7fb24ed5de 100644 --- a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.kt +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.kt @@ -88,7 +88,7 @@ object JvmResolveUtil { fun analyze(files: Collection, environment: KotlinCoreEnvironment, configuration: CompilerConfiguration): AnalysisResult = analyze(environment.project, files, configuration, environment::createPackagePartProvider) - private fun analyze( + fun analyze( project: Project, files: Collection, configuration: CompilerConfiguration, diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaForKotlinOverridePropertyDescriptor.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaForKotlinOverridePropertyDescriptor.kt index b17ef6e60be..1d987a46a90 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaForKotlinOverridePropertyDescriptor.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaForKotlinOverridePropertyDescriptor.kt @@ -13,9 +13,9 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations class JavaForKotlinOverridePropertyDescriptor( ownerDescriptor: ClassDescriptor, - getterMethod: SimpleFunctionDescriptor, - setterMethod: SimpleFunctionDescriptor?, - overriddenProperty: PropertyDescriptor + val getterMethod: SimpleFunctionDescriptor, + val setterMethod: SimpleFunctionDescriptor?, + val overriddenProperty: PropertyDescriptor ) : JavaPropertyDescriptor( ownerDescriptor, Annotations.EMPTY, diff --git a/generators/analysis-api-generator/build.gradle.kts b/generators/analysis-api-generator/build.gradle.kts index 19f8d1d3501..56dea7f6716 100644 --- a/generators/analysis-api-generator/build.gradle.kts +++ b/generators/analysis-api-generator/build.gradle.kts @@ -16,6 +16,7 @@ dependencies { testApi(projectTests(":compiler:tests-spec")) testApi(projectTests("::analysis:low-level-api-fir")) testApi(projectTests(":analysis:analysis-api-fir")) + testApi(projectTests(":analysis:analysis-api-fe10")) testApi(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) } testApiJUnit5() } diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt index f91514b0cca..ae3e1cb4c7f 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/GenerateAnalysisApiTests.kt @@ -24,6 +24,9 @@ import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirMemberScopeByFqNa import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByFqNameTest import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByPsiTest import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByReferenceTest +import org.jetbrains.kotlin.analysis.api.descriptors.test.components.* +import org.jetbrains.kotlin.analysis.api.descriptors.test.symbols.AbstractKtFe10SymbolByFqNameTest +import org.jetbrains.kotlin.analysis.api.descriptors.test.symbols.AbstractKtFe10SymbolByReferenceTest import org.jetbrains.kotlin.spec.utils.GeneralConfiguration import org.jetbrains.kotlin.spec.utils.tasks.detectDirsWithTestsMapFileOnly import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5 @@ -98,6 +101,60 @@ fun main(args: Array) { } } + testGroup("analysis/analysis-api-fe10/tests", "analysis/analysis-api/testData") { +// testClass { +// model("analysisSession/resolveCall") +// } + +// testClass { +// model("memberScopeByFqName") +// } + +// testClass { +// model("fileScopeTest", extension = "kt") +// } + +// testClass { +// model("symbols/symbolByPsi") +// } + +// testClass { +// model("components/compileTimeConstantEvaluator") +// } + + testClass { + model("symbols/symbolByFqName") + } + + testClass { + model("symbols/symbolByReference") + } + + testClass { + model("components/expectedExpressionType") + } + + testClass { + model("components/overridenDeclarations") + } + + testClass { + model("components/expressionType") + } + + testClass { + model("components/declarationRenderer") + } + +// testClass { +// model("referenceResolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) +// } + + testClass { + model("components/hasCommonSubtype") + } + } + testGroup("analysis/low-level-api-fir/tests", "compiler/fir/raw-fir/psi2fir/testData") { testClass { model("rawBuilder", testMethod = "doTest") diff --git a/prepare/ide-plugin-dependencies/high-level-api-fe10-for-ide/build.gradle.kts b/prepare/ide-plugin-dependencies/high-level-api-fe10-for-ide/build.gradle.kts new file mode 100644 index 00000000000..26628311014 --- /dev/null +++ b/prepare/ide-plugin-dependencies/high-level-api-fe10-for-ide/build.gradle.kts @@ -0,0 +1,5 @@ +plugins { + kotlin("jvm") +} + +publishJarsForIde(listOf(":analysis:analysis-api-fe10")) diff --git a/prepare/ide-plugin-dependencies/high-level-api-fe10-tests-for-ide/build.gradle.kts b/prepare/ide-plugin-dependencies/high-level-api-fe10-tests-for-ide/build.gradle.kts new file mode 100644 index 00000000000..5cb9a971115 --- /dev/null +++ b/prepare/ide-plugin-dependencies/high-level-api-fe10-tests-for-ide/build.gradle.kts @@ -0,0 +1,5 @@ +plugins { + kotlin("jvm") +} + +publishTestJarsForIde(listOf(":analysis:analysis-api-fe10")) diff --git a/settings.gradle b/settings.gradle index c1e4c2c55ee..ce01922f831 100644 --- a/settings.gradle +++ b/settings.gradle @@ -353,6 +353,8 @@ if (!buildProperties.inJpsBuildIdeaSync) { ":prepare:ide-plugin-dependencies:high-level-api-for-ide", ":prepare:ide-plugin-dependencies:high-level-api-fir-for-ide", ":prepare:ide-plugin-dependencies:high-level-api-fir-tests-for-ide", + ":prepare:ide-plugin-dependencies:high-level-api-fe10-for-ide", + ":prepare:ide-plugin-dependencies:high-level-api-fe10-tests-for-ide", ":prepare:ide-plugin-dependencies:analysis-api-providers-for-ide", ":prepare:ide-plugin-dependencies:analysis-project-structure-for-ide", ":prepare:ide-plugin-dependencies:symbol-light-classes-for-ide", @@ -478,7 +480,8 @@ include ":generators:analysis-api-generator", ":analysis:analysis-api-impl-base", ":analysis:analysis-api-providers", ":analysis:symbol-light-classes", - ":analysis:project-structure" + ":analysis:project-structure", + ":analysis:analysis-api-fe10" if (buildProperties.inJpsBuildIdeaSync) {