[FIR IDE] Enable call resolution tests in AAPI/FE10

Fix numerous cases in Fe10KtCallResolver so the tests pass correctly.
2021-11-02 21:23:45 +09:00
parent a653a57593
commit 9106a4bbc5
14 changed files with 554 additions and 32 deletions
@@ -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<KtTypeParameterSymbol, KtType> by cached {
+                val symbolicMap = LinkedHashMap<KtTypeParameterSymbol, KtType>(typeArguments.size)
+                for ((typeParameter, type) in typeArguments) {
+                    val typeParameterSymbol = KtFe10DescTypeParameterSymbol(typeParameter, analysisContext)
+                    symbolicMap[typeParameterSymbol] = type.toKtType(analysisContext)
+                }
+                return@cached symbolicMap
+            }
+
+            override fun getAsMap(): Map<KtTypeParameterSymbol, KtType> {
+                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? {
@@ -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");
+    }
+}
@@ -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<kotlin.Int>
@@ -1,3 +1,4 @@
 KtFunctionCall:
 argumentMapping = { 1 -> (a: kotlin.Int) }
-targetFunction = ERR<Unresolved call, [/C.get(a: kotlin.Int, b: kotlin.String): kotlin.Boolean]>
+targetFunction = ERR<Unresolved call, [/C.get(<dispatch receiver>: C, a: kotlin.Int, b: kotlin.String): kotlin.Boolean]>
+substitutor = <empty substitutor>
@@ -1,3 +1,4 @@
 KtFunctionCall:
 argumentMapping = { 1 -> (a: kotlin.Int), "foo" -> (b: kotlin.String) }
-targetFunction = ERR<Unresolved call, [/C.get(a: kotlin.Int, b: kotlin.String): kotlin.Boolean]>
+targetFunction = ERR<Unresolved call, [/C.get(<dispatch receiver>: C, a: kotlin.Int, b: kotlin.String): kotlin.Boolean]>
+substitutor = <empty substitutor>
@@ -1,3 +1,4 @@
 KtFunctionCall:
 argumentMapping = { 1 -> (a: kotlin.Int), false -> (value: kotlin.Boolean) }
-targetFunction = ERR<Unresolved call, [/C.set(a: kotlin.Int, b: kotlin.String, value: kotlin.Boolean): kotlin.Unit]>
+targetFunction = ERR<Unresolved call, [/C.set(<dispatch receiver>: C, a: kotlin.Int, b: kotlin.String, value: kotlin.Boolean): kotlin.Unit]>
+substitutor = <empty substitutor>
@@ -1,3 +1,4 @@
 KtFunctionCall:
 argumentMapping = { 1 -> (a: kotlin.Int), "foo" -> (b: kotlin.String), 3.14 -> (value: kotlin.Boolean) }
-targetFunction = ERR<Unresolved call, [/C.set(a: kotlin.Int, b: kotlin.String, value: kotlin.Boolean): kotlin.Unit]>
+targetFunction = ERR<Unresolved call, [/C.set(<dispatch receiver>: C, a: kotlin.Int, b: kotlin.String, value: kotlin.Boolean): kotlin.Unit]>
+substitutor = <empty substitutor>
@@ -0,0 +1,4 @@
+KtFunctionCall:
+argumentMapping = {  }
+targetFunction = <getter>(<dispatch receiver>: KtClass): kotlin.Int
+substitutor = <empty substitutor>
@@ -0,0 +1,4 @@
+KtFunctionCall:
+argumentMapping = {  }
+targetFunction = <getter>(<dispatch receiver>: KtClass): KtSubClass
+substitutor = <empty substitutor>
@@ -0,0 +1,4 @@
+KtFunctionCall:
+argumentMapping = { 42 -> (value: kotlin.Int) }
+targetFunction = <setter>(<dispatch receiver>: KtClass, value: kotlin.Int): kotlin.Unit
+substitutor = <empty substitutor>
@@ -1,3 +0,0 @@
-KtFunctionCall:
-argumentMapping = { 2 -> (other: kotlin.Int) }
-targetFunction = /to(<receiver>: kotlin.Int, other: kotlin.Int): kotlin.Int
@@ -1,3 +1,4 @@
 KtFunctionCall:
 argumentMapping = {  }
-targetFunction = ERR<Unresolved call, [/foo(): kotlin.Unit]>
+targetFunction = ERR<Unresolved call, [/foo(): kotlin.Unit]>
+substitutor = <empty substitutor>
@@ -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(<dispatch receiver>: 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 = <empty substitutor>
@@ -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<String>) {
        }

        testGroup("analysis/analysis-api-fe10/tests", "analysis/analysis-api/testData") {
-//            testClass<AbstractKtFe10ResolveCallTest> {
-//                model("analysisSession/resolveCall")
-//            }
+            testClass<AbstractKtFe10ResolveCallTest> {
+                model("analysisSession/resolveCall")
+            }

 //            testClass<AbstractKtFe10MemberScopeByFqNameTest> {
 //                model("scopes/memberScopeByFqName")