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 index 9c17a1d6539..57c54211a2b 100644 --- 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 @@ -9,31 +9,36 @@ import org.jetbrains.kotlin.analysis.api.calls.* import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.* 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.calculateCallableId import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.callableIdIfNotLocal import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol +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.utils.cached import org.jetbrains.kotlin.analysis.api.diagnostics.KtNonBoundToPsiErrorDiagnostic +import org.jetbrains.kotlin.analysis.api.impl.base.KtMapBackedSubstitutor 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.KtTypeParameterSymbol 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.types.KtType 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.inference.substitute 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 +import org.jetbrains.kotlin.types.* internal class KtFe10CallResolver( override val analysisSession: KtFe10AnalysisSession @@ -48,27 +53,27 @@ internal class KtFe10CallResolver( override fun resolveAccessorCall(call: KtSimpleNameExpression): KtCall? { val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS) val resolvedCall = call.getResolvedCall(bindingContext) ?: return null - val resultingDescriptor = resolvedCall.resultingDescriptor + val targetDescriptor = resolvedCall.candidateDescriptor - if (resultingDescriptor is PropertyDescriptor) { + if (targetDescriptor is PropertyDescriptor) { @Suppress("DEPRECATION") val access = call.readWriteAccessWithFullExpressionWithPossibleResolve( readWriteAccessWithFullExpressionByResolve = { null } ).first val setterValue = findAssignment(call)?.right - val accessorSymbol = when (resultingDescriptor) { + val accessorSymbol = when (targetDescriptor) { is SyntheticJavaPropertyDescriptor -> { when { - access.isWrite -> resultingDescriptor.setMethod?.let { KtFe10DescFunctionSymbol(it, analysisContext) } - access.isRead -> KtFe10DescFunctionSymbol(resultingDescriptor.getMethod, analysisContext) + access.isWrite -> targetDescriptor.setMethod?.let { KtFe10DescFunctionSymbol(it, analysisContext) } + access.isRead -> KtFe10DescFunctionSymbol(targetDescriptor.getMethod, analysisContext) else -> null } } else -> { when { - access.isWrite -> resultingDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisContext) } - access.isRead -> resultingDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisContext) } + access.isWrite -> targetDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisContext) } + access.isRead -> targetDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisContext) } else -> null } } @@ -89,7 +94,7 @@ internal class KtFe10CallResolver( argumentMapping[setterValue] = setterParameterSymbol } - return KtFunctionCall(argumentMapping, target, KtSubstitutor.Empty(token), token) + return KtFunctionCall(argumentMapping, target, getSubstitutor(resolvedCall), token) } } @@ -112,6 +117,54 @@ internal class KtFe10CallResolver( return resolveCall(call, isUsualCall = false) } + private fun getSubstitutor(vararg resolvedCall: ResolvedCall<*>): KtSubstitutor { + val typeArguments = if (resolvedCall.size == 1) { + resolvedCall[0].typeArguments + } else { + buildMap { + resolvedCall.forEach { putAll(it.typeArguments) } + } + } + + if (typeArguments.isEmpty()) { + return KtSubstitutor.Empty(analysisContext.token) + } + + val typeSubstitution = object : TypeConstructorSubstitution() { + override fun get(key: TypeConstructor): TypeProjection? { + val type = typeArguments[key.declarationDescriptor] ?: return null + return TypeProjectionImpl(Variance.INVARIANT, type) + } + + override fun isEmpty() = typeArguments.isEmpty() + } + + val typeSubstitutor = TypeSubstitutor.create(typeSubstitution) + + return object : KtMapBackedSubstitutor { + override val token: ValidityToken + get() = analysisContext.token + + val map: Map by cached { + val symbolicMap = LinkedHashMap(typeArguments.size) + for ((typeParameter, type) in typeArguments) { + val typeParameterSymbol = KtFe10DescTypeParameterSymbol(typeParameter, analysisContext) + symbolicMap[typeParameterSymbol] = type.toKtType(analysisContext) + } + return@cached symbolicMap + } + + override fun getAsMap(): Map { + return map + } + + override fun substituteOrNull(type: KtType): KtType { + require(type is KtFe10Type) + return typeSubstitutor.substitute(type.type).toKtType(analysisContext) + } + } + } + /** * Analyze the given call element (a function call, unary/binary operator call, or convention call). * @@ -133,16 +186,16 @@ internal class KtFe10CallResolver( return KtErrorCallTarget(listOf(targetSymbol), diagnostic, token) } - val targetDescriptor = resolvedCall.resultingDescriptor + val targetDescriptor = resolvedCall.candidateDescriptor val callableSymbol = targetDescriptor.toKtCallableSymbol(analysisContext) as? KtFunctionLikeSymbol ?: return null if (resolvedCall is VariableAsFunctionResolvedCall) { - val variableDescriptor = resolvedCall.variableCall.resultingDescriptor + val variableDescriptor = resolvedCall.variableCall.candidateDescriptor val variableSymbol = variableDescriptor.toKtCallableSymbol(analysisContext) as? KtVariableLikeSymbol ?: return null - val substitutor = KtSubstitutor.Empty(token) - return if (resolvedCall.functionCall.resultingDescriptor.callableIdIfNotLocal in kotlinFunctionInvokeCallableIds) { + val substitutor = getSubstitutor(resolvedCall.functionCall, resolvedCall.variableCall) + return if (resolvedCall.functionCall.candidateDescriptor.callableIdIfNotLocal in kotlinFunctionInvokeCallableIds) { KtFunctionalTypeVariableCall(variableSymbol, argumentMapping, getTarget(callableSymbol), substitutor, token) } else { KtVariableWithInvokeFunctionCall(variableSymbol, argumentMapping, getTarget(callableSymbol), substitutor, token) @@ -154,12 +207,12 @@ internal class KtFe10CallResolver( } if (isUsualCall) { - if (targetDescriptor.isAnnotationConstructor()) { + if (targetDescriptor.isAnnotationConstructor() && (call is KtAnnotationEntry || call.parent is KtAnnotationEntry)) { return KtAnnotationCall(argumentMapping, getTarget(callableSymbol), token) } } - return KtFunctionCall(argumentMapping, getTarget(callableSymbol), KtSubstitutor.Empty(token), token) + return KtFunctionCall(argumentMapping, getTarget(callableSymbol), getSubstitutor(resolvedCall), token) } private fun getUnresolvedCall(call: KtElement): KtCall? { diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10ResolveCallTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10ResolveCallTestGenerated.java new file mode 100644 index 00000000000..7ef2989c092 --- /dev/null +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/KtFe10ResolveCallTestGenerated.java @@ -0,0 +1,452 @@ +/* + * 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.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/analysisSession/resolveCall") +@TestDataPath("$PROJECT_ROOT") +public class KtFe10ResolveCallTestGenerated extends AbstractKtFe10ResolveCallTest { + @Test + public void testAllFilesPresentInResolveCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/analysisSession/resolveCall"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotationEntry.kt") + public void testAnnotationEntry() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationEntry.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_arrayOf.kt") + public void testAnnotationInAnnotation_arrayOf() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationInAnnotation_arrayOf.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_collectionLiteral.kt") + public void testAnnotationInAnnotation_collectionLiteral() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationInAnnotation_collectionLiteral.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_multipleAnnotations_arrayOf.kt") + public void testAnnotationInAnnotation_multipleAnnotations_arrayOf() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationInAnnotation_multipleAnnotations_arrayOf.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_multipleAnnotations_collectionLiteral.kt") + public void testAnnotationInAnnotation_multipleAnnotations_collectionLiteral() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationInAnnotation_multipleAnnotations_collectionLiteral.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_noarg.kt") + public void testAnnotationInAnnotation_noarg() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationInAnnotation_noarg.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_vararg.kt") + public void testAnnotationInAnnotation_vararg() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationInAnnotation_vararg.kt"); + } + + @Test + @TestMetadata("annotationOnDelegate.kt") + public void testAnnotationOnDelegate() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnDelegate.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_asT.kt") + public void testAnnotationOnExpression_asT() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnExpression_asT.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_destructuring.kt") + public void testAnnotationOnExpression_destructuring() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnExpression_destructuring.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_if.kt") + public void testAnnotationOnExpression_if() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnExpression_if.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_whenBranch.kt") + public void testAnnotationOnExpression_whenBranch() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnExpression_whenBranch.kt"); + } + + @Test + @TestMetadata("annotationOnFile.kt") + public void testAnnotationOnFile() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnFile.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_param.kt") + public void testAnnotationOnParameter_param() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnParameter_param.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_parameterProperty.kt") + public void testAnnotationOnParameter_parameterProperty() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnParameter_parameterProperty.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_reified.kt") + public void testAnnotationOnParameter_reified() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnParameter_reified.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_setparam.kt") + public void testAnnotationOnParameter_setparam() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnParameter_setparam.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_field.kt") + public void testAnnotationOnProperty_field() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnProperty_field.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_get.kt") + public void testAnnotationOnProperty_get() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnProperty_get.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_property.kt") + public void testAnnotationOnProperty_property() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnProperty_property.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_set.kt") + public void testAnnotationOnProperty_set() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnProperty_set.kt"); + } + + @Test + @TestMetadata("annotationOnReceiver.kt") + public void testAnnotationOnReceiver() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/annotationOnReceiver.kt"); + } + + @Test + @TestMetadata("arrayOfInAnnotation.kt") + public void testArrayOfInAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/arrayOfInAnnotation.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_super.kt") + public void testDelegatedConstructorCall_super() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/delegatedConstructorCall_super.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_super_unresolved.kt") + public void testDelegatedConstructorCall_super_unresolved() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/delegatedConstructorCall_super_unresolved.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_this.kt") + public void testDelegatedConstructorCall_this() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/delegatedConstructorCall_this.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_this_unresolved.kt") + public void testDelegatedConstructorCall_this_unresolved() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/delegatedConstructorCall_this_unresolved.kt"); + } + + @Test + @TestMetadata("enumAsAnnotationValue.kt") + public void testEnumAsAnnotationValue() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/enumAsAnnotationValue.kt"); + } + + @Test + @TestMetadata("functionCallInTheSameFile.kt") + public void testFunctionCallInTheSameFile() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallInTheSameFile.kt"); + } + + @Test + @TestMetadata("functionCallWithExtensionReceiverAndTypeArgument.kt") + public void testFunctionCallWithExtensionReceiverAndTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithExtensionReceiverAndTypeArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithLambdaArgument.kt") + public void testFunctionCallWithLambdaArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithLambdaArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithNamedArgument.kt") + public void testFunctionCallWithNamedArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithNamedArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithNonTrailingLambdaArgument.kt") + public void testFunctionCallWithNonTrailingLambdaArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithNonTrailingLambdaArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithSpreadArgument.kt") + public void testFunctionCallWithSpreadArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithSpreadArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithTypeArgument.kt") + public void testFunctionCallWithTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithTypeArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithVarargArgument.kt") + public void testFunctionCallWithVarargArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionCallWithVarargArgument.kt"); + } + + @Test + @TestMetadata("functionWithReceiverCall.kt") + public void testFunctionWithReceiverCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionWithReceiverCall.kt"); + } + + @Test + @TestMetadata("functionWithReceiverSafeCall.kt") + public void testFunctionWithReceiverSafeCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/functionWithReceiverSafeCall.kt"); + } + + @Test + @TestMetadata("implicitConstructorDelegationCall.kt") + public void testImplicitConstructorDelegationCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/implicitConstructorDelegationCall.kt"); + } + + @Test + @TestMetadata("implicitConstuctorCall.kt") + public void testImplicitConstuctorCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/implicitConstuctorCall.kt"); + } + + @Test + @TestMetadata("implicitJavaConstuctorCall.kt") + public void testImplicitJavaConstuctorCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/implicitJavaConstuctorCall.kt"); + } + + @Test + @TestMetadata("indexedGet.kt") + public void testIndexedGet() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/indexedGet.kt"); + } + + @Test + @TestMetadata("indexedGetWithNotEnoughArgs.kt") + public void testIndexedGetWithNotEnoughArgs() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("indexedGetWithTooManyArgs.kt") + public void testIndexedGetWithTooManyArgs() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithTooManyArgs.kt"); + } + + @Test + @TestMetadata("indexedSet.kt") + public void testIndexedSet() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/indexedSet.kt"); + } + + @Test + @TestMetadata("indexedSetWithNotEnoughArgs.kt") + public void testIndexedSetWithNotEnoughArgs() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("indexedSetWithTooManyArgs.kt") + public void testIndexedSetWithTooManyArgs() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithTooManyArgs.kt"); + } + + @Test + @TestMetadata("intArrayOfInAnnotation.kt") + public void testIntArrayOfInAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/intArrayOfInAnnotation.kt"); + } + + @Test + @TestMetadata("javaFunctionCall.kt") + public void testJavaFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/javaFunctionCall.kt"); + } + + @Test + @TestMetadata("javaPropertyGetter.kt") + public void testJavaPropertyGetter() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/javaPropertyGetter.kt"); + } + + @Test + @TestMetadata("javaPropertyNestedGetter.kt") + public void testJavaPropertyNestedGetter() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/javaPropertyNestedGetter.kt"); + } + + @Test + @TestMetadata("javaPropertySetter.kt") + public void testJavaPropertySetter() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/javaPropertySetter.kt"); + } + + @Test + @TestMetadata("javaPropertySetterIncomplete.kt") + public void testJavaPropertySetterIncomplete() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/javaPropertySetterIncomplete.kt"); + } + + @Test + @TestMetadata("kotlinPropertyGetter.kt") + public void testKotlinPropertyGetter() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyGetter.kt"); + } + + @Test + @TestMetadata("kotlinPropertyNestedGetter.kt") + public void testKotlinPropertyNestedGetter() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyNestedGetter.kt"); + } + + @Test + @TestMetadata("kotlinPropertySetter.kt") + public void testKotlinPropertySetter() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertySetter.kt"); + } + + @Test + @TestMetadata("memberFunctionCallWithTypeArgument.kt") + public void testMemberFunctionCallWithTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/memberFunctionCallWithTypeArgument.kt"); + } + + @Test + @TestMetadata("resolveCallInSuperConstructorParam.kt") + public void testResolveCallInSuperConstructorParam() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/resolveCallInSuperConstructorParam.kt"); + } + + @Test + @TestMetadata("samConstructorCall.kt") + public void testSamConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/samConstructorCall.kt"); + } + + @Test + @TestMetadata("simpleCallWithNonMatchingArgs.kt") + public void testSimpleCallWithNonMatchingArgs() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.kt"); + } + + @Test + @TestMetadata("unresolvedSuperReference.kt") + public void testUnresolvedSuperReference() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/unresolvedSuperReference.kt"); + } + + @Test + @TestMetadata("variableAsFunction.kt") + public void testVariableAsFunction() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunction.kt"); + } + + @Test + @TestMetadata("variableAsFunctionLikeCall.kt") + public void testVariableAsFunctionLikeCall() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionLikeCall.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterName.kt") + public void testVariableAsFunctionWithParameterName() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterName.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotation.kt") + public void testVariableAsFunctionWithParameterNameAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameAnnotation.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotationConflict.kt") + public void testVariableAsFunctionWithParameterNameAnnotationConflict() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameGeneric.kt") + public void testVariableAsFunctionWithParameterNameGeneric() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameGeneric.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameInNonFunctionType.kt") + public void testVariableAsFunctionWithParameterNameInNonFunctionType() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameInNonFunctionType.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameMixed.kt") + public void testVariableAsFunctionWithParameterNameMixed() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameMixed.kt"); + } + + @Test + @TestMetadata("variableWithExtensionInvoke.kt") + public void testVariableWithExtensionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableWithExtensionInvoke.kt"); + } + + @Test + @TestMetadata("variableWithMemberInvoke.kt") + public void testVariableWithMemberInvoke() throws Exception { + runTest("analysis/analysis-api/testData/analysisSession/resolveCall/variableWithMemberInvoke.kt"); + } +} diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/arrayOfInAnnotation.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/arrayOfInAnnotation.descriptors.txt deleted file mode 100644 index b2dec158724..00000000000 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/arrayOfInAnnotation.descriptors.txt +++ /dev/null @@ -1,3 +0,0 @@ -KtFunctionCall: -argumentMapping = { 1 -> (vararg elements: kotlin.Int), 2 -> (vararg elements: kotlin.Int), 3 -> (vararg elements: kotlin.Int) } -targetFunction = kotlin/arrayOf(vararg elements: kotlin.Int): kotlin.Array \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithNotEnoughArgs.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithNotEnoughArgs.descriptors.txt index 9fe3d74bbb4..ba40818edb9 100644 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithNotEnoughArgs.descriptors.txt +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithNotEnoughArgs.descriptors.txt @@ -1,3 +1,4 @@ KtFunctionCall: argumentMapping = { 1 -> (a: kotlin.Int) } -targetFunction = ERR \ No newline at end of file +targetFunction = ERR: C, a: kotlin.Int, b: kotlin.String): kotlin.Boolean]> +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithTooManyArgs.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithTooManyArgs.descriptors.txt index 68097c9a639..d4daa8cec0f 100644 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithTooManyArgs.descriptors.txt +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedGetWithTooManyArgs.descriptors.txt @@ -1,3 +1,4 @@ KtFunctionCall: argumentMapping = { 1 -> (a: kotlin.Int), "foo" -> (b: kotlin.String) } -targetFunction = ERR \ No newline at end of file +targetFunction = ERR: C, a: kotlin.Int, b: kotlin.String): kotlin.Boolean]> +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithNotEnoughArgs.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithNotEnoughArgs.descriptors.txt index f4b505bb4e4..d3e2fa33727 100644 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithNotEnoughArgs.descriptors.txt +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithNotEnoughArgs.descriptors.txt @@ -1,3 +1,4 @@ KtFunctionCall: argumentMapping = { 1 -> (a: kotlin.Int), false -> (value: kotlin.Boolean) } -targetFunction = ERR \ No newline at end of file +targetFunction = ERR: C, a: kotlin.Int, b: kotlin.String, value: kotlin.Boolean): kotlin.Unit]> +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithTooManyArgs.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithTooManyArgs.descriptors.txt index 5fd152457a9..6ed0efbd0d3 100644 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithTooManyArgs.descriptors.txt +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/indexedSetWithTooManyArgs.descriptors.txt @@ -1,3 +1,4 @@ KtFunctionCall: argumentMapping = { 1 -> (a: kotlin.Int), "foo" -> (b: kotlin.String), 3.14 -> (value: kotlin.Boolean) } -targetFunction = ERR \ No newline at end of file +targetFunction = ERR: C, a: kotlin.Int, b: kotlin.String, value: kotlin.Boolean): kotlin.Unit]> +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyGetter.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyGetter.descriptors.txt new file mode 100644 index 00000000000..30236aa030d --- /dev/null +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyGetter.descriptors.txt @@ -0,0 +1,4 @@ +KtFunctionCall: +argumentMapping = { } +targetFunction = (: KtClass): kotlin.Int +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyNestedGetter.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyNestedGetter.descriptors.txt new file mode 100644 index 00000000000..5baba842987 --- /dev/null +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertyNestedGetter.descriptors.txt @@ -0,0 +1,4 @@ +KtFunctionCall: +argumentMapping = { } +targetFunction = (: KtClass): KtSubClass +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertySetter.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertySetter.descriptors.txt new file mode 100644 index 00000000000..d7d54d9a9db --- /dev/null +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/kotlinPropertySetter.descriptors.txt @@ -0,0 +1,4 @@ +KtFunctionCall: +argumentMapping = { 42 -> (value: kotlin.Int) } +targetFunction = (: KtClass, value: kotlin.Int): kotlin.Unit +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/resolveCallInSuperConstructorParam.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/resolveCallInSuperConstructorParam.descriptors.txt deleted file mode 100644 index 778e7d157b4..00000000000 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/resolveCallInSuperConstructorParam.descriptors.txt +++ /dev/null @@ -1,3 +0,0 @@ -KtFunctionCall: -argumentMapping = { 2 -> (other: kotlin.Int) } -targetFunction = /to(: kotlin.Int, other: kotlin.Int): kotlin.Int \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.descriptors.txt index 69e167d4755..2b2e304a990 100644 --- a/analysis/analysis-api/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.descriptors.txt +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.descriptors.txt @@ -1,3 +1,4 @@ KtFunctionCall: argumentMapping = { } -targetFunction = ERR \ No newline at end of file +targetFunction = ERR +substitutor = \ No newline at end of file diff --git a/analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict.descriptors.txt b/analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict.descriptors.txt new file mode 100644 index 00000000000..8d63e1b22f7 --- /dev/null +++ b/analysis/analysis-api/testData/analysisSession/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict.descriptors.txt @@ -0,0 +1,5 @@ +KtFunctionalTypeVariableCall: +target = x: kotlin.Function2<@R|kotlin.ParameterName|(name = String(a)) @R|kotlin.ParameterName|(name = String(notMe)) kotlin.Int, @R|kotlin.ParameterName|(name = String(b)) @R|kotlin.ParameterName|(name = String(meNeither)) kotlin.String, kotlin.Unit> +argumentMapping = { 1 -> (a: @R|kotlin.ParameterName|(name = String(a)) @R|kotlin.ParameterName|(name = String(notMe)) kotlin.Int), "" -> (b: @R|kotlin.ParameterName|(name = String(b)) @R|kotlin.ParameterName|(name = String(meNeither)) kotlin.String) } +targetFunction = kotlin/Function2.invoke(: kotlin.Function2<@R|kotlin.ParameterName|(name = String(a)) @R|kotlin.ParameterName|(name = String(notMe)) kotlin.Int, @R|kotlin.ParameterName|(name = String(b)) @R|kotlin.ParameterName|(name = String(meNeither)) kotlin.String, kotlin.Unit>, a: @R|kotlin.ParameterName|(name = String(a)) @R|kotlin.ParameterName|(name = String(notMe)) kotlin.Int, b: @R|kotlin.ParameterName|(name = String(b)) @R|kotlin.ParameterName|(name = String(meNeither)) kotlin.String): kotlin.Unit +substitutor = 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 80e15e19810..b2aa6a2304f 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 @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.generators.tests.analysis.api +import org.jetbrains.kotlin.analysis.api.descriptors.test.AbstractKtFe10ResolveCallTest 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.AbstractKtFe10SymbolByPsiTest @@ -124,9 +125,9 @@ fun main(args: Array) { } testGroup("analysis/analysis-api-fe10/tests", "analysis/analysis-api/testData") { -// testClass { -// model("analysisSession/resolveCall") -// } + testClass { + model("analysisSession/resolveCall") + } // testClass { // model("scopes/memberScopeByFqName")