FE1.0 Analysis API: comment out KtFe10CallResolver for now

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

@@ -5,40 +5,12 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.components
 
-import org.jetbrains.kotlin.analysis.api.calls.*
+import org.jetbrains.kotlin.analysis.api.calls.KtCallInfo
-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.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.psi.KtElement
-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
@@ -50,203 +22,207 @@ internal class KtFe10CallResolver(
     override val token: ValidityToken
         get() = analysisSession.token
 
-    override fun resolveAccessorCall(call: KtSimpleNameExpression): KtCall? {
+    override fun resolveCall(psi: KtElement): KtCallInfo? {
-        val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
-        val resolvedCall = call.getResolvedCall(bindingContext) ?: return null
-        val targetDescriptor = resolvedCall.candidateDescriptor
-
-        if (targetDescriptor is PropertyDescriptor) {
-            @Suppress("DEPRECATION")
-            val access = call.readWriteAccessWithFullExpressionWithPossibleResolve(
-                readWriteAccessWithFullExpressionByResolve = { null }
-            ).first
-
-            val setterValue = findAssignment(call)?.right
-            val accessorSymbol = when (targetDescriptor) {
-                is SyntheticJavaPropertyDescriptor -> {
-                    when {
-                        access.isWrite -> targetDescriptor.setMethod?.let { KtFe10DescFunctionSymbol.build(it, analysisContext) }
-                        access.isRead -> KtFe10DescFunctionSymbol.build(targetDescriptor.getMethod, analysisContext)
-                        else -> null
-                    }
-                }
-                else -> {
-                    when {
-                        access.isWrite -> targetDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisContext) }
-                        access.isRead -> targetDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisContext) }
-                        else -> null
-                    }
-                }
-            }
-
-            if (accessorSymbol != null) {
-                val target = when {
-                    !access.isWrite || setterValue != null -> KtSuccessCallTarget(accessorSymbol, token)
-                    else -> {
-                        val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, "Setter value is missing", token)
-                        KtErrorCallTarget(listOf(accessorSymbol), diagnostic, token)
-                    }
-                }
-
-                val argumentMapping = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
-                if (access.isWrite && setterValue != null) {
-                    val setterParameterSymbol = accessorSymbol.valueParameters.single()
-                    argumentMapping[setterValue] = setterParameterSymbol
-                }
-
-                return KtFunctionCall(argumentMapping, target, getSubstitutor(resolvedCall), token)
-            }
-        }
-
         return null
     }
 
-    override fun resolveCall(call: KtCallElement): KtCall? = withValidityAssertion {
+//    override fun resolveAccessorCall(call: KtSimpleNameExpression): KtCall? {
-        return resolveCall(call, isUsualCall = true)
+//        val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
-    }
+//        val resolvedCall = call.getResolvedCall(bindingContext) ?: return null
-
+//        val targetDescriptor = resolvedCall.candidateDescriptor
-    override fun resolveCall(call: KtBinaryExpression): KtCall? = withValidityAssertion {
+//
-        return resolveCall(call, isUsualCall = false)
+//        if (targetDescriptor is PropertyDescriptor) {
-    }
+//            @Suppress("DEPRECATION")
-
+//            val access = call.readWriteAccessWithFullExpressionWithPossibleResolve(
-    override fun resolveCall(call: KtUnaryExpression): KtCall? = withValidityAssertion {
+//                readWriteAccessWithFullExpressionByResolve = { null }
-        return resolveCall(call, isUsualCall = false)
+//            ).first
-    }
+//
-
+//            val setterValue = findAssignment(call)?.right
-    override fun resolveCall(call: KtArrayAccessExpression): KtCall? = withValidityAssertion {
+//            val accessorSymbol = when (targetDescriptor) {
-        return resolveCall(call, isUsualCall = false)
+//                is SyntheticJavaPropertyDescriptor -> {
-    }
+//                    when {
-
+//                        access.isWrite -> targetDescriptor.setMethod?.let { KtFe10DescFunctionSymbol.build(it, analysisContext) }
-    private fun getSubstitutor(vararg resolvedCall: ResolvedCall<*>): KtSubstitutor {
+//                        access.isRead -> KtFe10DescFunctionSymbol.build(targetDescriptor.getMethod, analysisContext)
-        val typeArguments = if (resolvedCall.size == 1) {
+//                        else -> null
-            resolvedCall[0].typeArguments
+//                    }
-        } else {
+//                }
-            buildMap {
+//                else -> {
-                resolvedCall.forEach { putAll(it.typeArguments) }
+//                    when {
-            }
+//                        access.isWrite -> targetDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisContext) }
-        }
+//                        access.isRead -> targetDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisContext) }
-
+//                        else -> null
-        if (typeArguments.isEmpty()) {
+//                    }
-            return KtSubstitutor.Empty(analysisContext.token)
+//                }
-        }
+//            }
-
+//
-        val typeSubstitution = object : TypeConstructorSubstitution() {
+//            if (accessorSymbol != null) {
-            override fun get(key: TypeConstructor): TypeProjection? {
+//                val target = when {
-                val type = typeArguments[key.declarationDescriptor] ?: return null
+//                    !access.isWrite || setterValue != null -> KtSuccessCallTarget(accessorSymbol, token)
-                return TypeProjectionImpl(Variance.INVARIANT, type)
+//                    else -> {
-            }
+//                        val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, "Setter value is missing", token)
-
+//                        KtErrorCallTarget(listOf(accessorSymbol), diagnostic, token)
-            override fun isEmpty() = typeArguments.isEmpty()
+//                    }
-        }
+//                }
-
+//
-        val typeSubstitutor = TypeSubstitutor.create(typeSubstitution)
+//                val argumentMapping = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
-
+//                if (access.isWrite && setterValue != null) {
-        return object : KtMapBackedSubstitutor {
+//                    val setterParameterSymbol = accessorSymbol.valueParameters.single()
-            override val token: ValidityToken
+//                    argumentMapping[setterValue] = setterParameterSymbol
-                get() = analysisContext.token
+//                }
-
+//
-            val map: Map<KtTypeParameterSymbol, KtType> by cached {
+//                return KtFunctionCall(argumentMapping, target, getSubstitutor(resolvedCall), token)
-                val symbolicMap = LinkedHashMap<KtTypeParameterSymbol, KtType>(typeArguments.size)
+//            }
-                for ((typeParameter, type) in typeArguments) {
+//        }
-                    val typeParameterSymbol = KtFe10DescTypeParameterSymbol(typeParameter, analysisContext)
+//
-                    symbolicMap[typeParameterSymbol] = type.toKtType(analysisContext)
+//        return null
-                }
+//    }
-                return@cached symbolicMap
+//
-            }
+//    override fun resolveCall(call: KtCallElement): KtCall? = withValidityAssertion {
-
+//        return resolveCall(call, isUsualCall = true)
-            override fun getAsMap(): Map<KtTypeParameterSymbol, KtType> {
+//    }
-                return map
+//
-            }
+//    override fun resolveCall(call: KtBinaryExpression): KtCall? = withValidityAssertion {
-
+//        return resolveCall(call, isUsualCall = false)
-            override fun substituteOrNull(type: KtType): KtType {
+//    }
-                require(type is KtFe10Type)
+//
-                return typeSubstitutor.substitute(type.type).toKtType(analysisContext)
+//    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.
+//    private fun getSubstitutor(vararg resolvedCall: ResolvedCall<*>): KtSubstitutor {
-     * @param isUsualCall `true` if the call is a usual function call (`foo()` or `foo {}`).
+//        val typeArguments = if (resolvedCall.size == 1) {
-     */
+//            resolvedCall[0].typeArguments
-    private fun resolveCall(call: KtElement, isUsualCall: Boolean): KtCall? {
+//        } else {
-        val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+//            buildMap {
-        val resolvedCall = call.getResolvedCall(bindingContext) ?: return getUnresolvedCall(call)
+//                resolvedCall.forEach { putAll(it.typeArguments) }
-
+//            }
-        val argumentMapping = createArgumentMapping(resolvedCall)
+//        }
-
+//
-        fun getTarget(targetSymbol: KtFunctionLikeSymbol): KtCallTarget {
+//        if (typeArguments.isEmpty()) {
-            if (resolvedCall.status == ResolutionStatus.SUCCESS) {
+//            return KtSubstitutor.Empty(analysisContext.token)
-                return KtSuccessCallTarget(targetSymbol, token)
+//        }
-            }
+//
-
+//        val typeSubstitution = object : TypeConstructorSubstitution() {
-            val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+//            override fun get(key: TypeConstructor): TypeProjection? {
-            return KtErrorCallTarget(listOf(targetSymbol), diagnostic, token)
+//                val type = typeArguments[key.declarationDescriptor] ?: return null
-        }
+//                return TypeProjectionImpl(Variance.INVARIANT, type)
-
+//            }
-        val targetDescriptor = resolvedCall.candidateDescriptor
+//
-
+//            override fun isEmpty() = typeArguments.isEmpty()
-        val callableSymbol = targetDescriptor.toKtCallableSymbol(analysisContext) as? KtFunctionLikeSymbol ?: return null
+//        }
-
+//
-        if (resolvedCall is VariableAsFunctionResolvedCall) {
+//        val typeSubstitutor = TypeSubstitutor.create(typeSubstitution)
-            val variableDescriptor = resolvedCall.variableCall.candidateDescriptor
+//
-            val variableSymbol = variableDescriptor.toKtCallableSymbol(analysisContext) as? KtVariableLikeSymbol ?: return null
+//        return object : KtMapBackedSubstitutor {
-
+//            override val token: ValidityToken
-            val substitutor = getSubstitutor(resolvedCall.functionCall, resolvedCall.variableCall)
+//                get() = analysisContext.token
-            return if (resolvedCall.functionCall.candidateDescriptor.callableIdIfNotLocal in kotlinFunctionInvokeCallableIds) {
+//
-                KtFunctionalTypeVariableCall(variableSymbol, argumentMapping, getTarget(callableSymbol), substitutor, token)
+//            val map: Map<KtTypeParameterSymbol, KtType> by cached {
-            } else {
+//                val symbolicMap = LinkedHashMap<KtTypeParameterSymbol, KtType>(typeArguments.size)
-                KtVariableWithInvokeFunctionCall(variableSymbol, argumentMapping, getTarget(callableSymbol), substitutor, token)
+//                for ((typeParameter, type) in typeArguments) {
-            }
+//                    val typeParameterSymbol = KtFe10DescTypeParameterSymbol(typeParameter, analysisContext)
-        }
+//                    symbolicMap[typeParameterSymbol] = type.toKtType(analysisContext)
-
+//                }
-        if (call is KtConstructorDelegationCall) {
+//                return@cached symbolicMap
-            return KtDelegatedConstructorCall(argumentMapping, getTarget(callableSymbol), call.kind, token)
+//            }
-        }
+//
-
+//            override fun getAsMap(): Map<KtTypeParameterSymbol, KtType> {
-        if (isUsualCall) {
+//                return map
-            if (targetDescriptor.isAnnotationConstructor() && (call is KtAnnotationEntry || call.parent is KtAnnotationEntry)) {
+//            }
-                return KtAnnotationCall(argumentMapping, getTarget(callableSymbol), token)
+//
-            }
+//            override fun substituteOrNull(type: KtType): KtType {
-        }
+//                require(type is KtFe10Type)
-
+//                return typeSubstitutor.substitute(type.type).toKtType(analysisContext)
-        return KtFunctionCall(argumentMapping, getTarget(callableSymbol), getSubstitutor(resolvedCall), token)
+//            }
-    }
+//        }
-
+//    }
-    private fun getUnresolvedCall(call: KtElement): KtCall? {
+//
-        return when (call) {
+//    /**
-            is KtSuperTypeCallEntry -> {
+//     * Analyze the given call element (a function call, unary/binary operator call, or convention call).
-                val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+//     *
-                val target = KtErrorCallTarget(emptyList(), diagnostic, token)
+//     * @param call the call element to analyze.
-                KtDelegatedConstructorCall(LinkedHashMap(), target, KtDelegatedConstructorCallKind.SUPER_CALL, token)
+//     * @param isUsualCall `true` if the call is a usual function call (`foo()` or `foo {}`).
-            }
+//     */
-            is KtConstructorDelegationCall -> {
+//    private fun resolveCall(call: KtElement, isUsualCall: Boolean): KtCall? {
-                val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+//        val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
-                val target = KtErrorCallTarget(emptyList(), diagnostic, token)
+//        val resolvedCall = call.getResolvedCall(bindingContext) ?: return getUnresolvedCall(call)
-                return KtDelegatedConstructorCall(LinkedHashMap(), target, call.kind, token)
+//
-            }
+//        val argumentMapping = createArgumentMapping(resolvedCall)
-            else -> null
+//
-        }
+//        fun getTarget(targetSymbol: KtFunctionLikeSymbol): KtCallTarget {
-    }
+//            if (resolvedCall.status == ResolutionStatus.SUCCESS) {
-
+//                return KtSuccessCallTarget(targetSymbol, token)
-    private val KtConstructorDelegationCall.kind: KtDelegatedConstructorCallKind
+//            }
-        get() = when {
+//
-            isCallToThis -> KtDelegatedConstructorCallKind.THIS_CALL
+//            val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
-            else -> KtDelegatedConstructorCallKind.SUPER_CALL
+//            return KtErrorCallTarget(listOf(targetSymbol), diagnostic, token)
-        }
+//        }
-
+//
-    private fun createArgumentMapping(resolvedCall: ResolvedCall<*>): LinkedHashMap<KtExpression, KtValueParameterSymbol> {
+//        val targetDescriptor = resolvedCall.candidateDescriptor
-        val result = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
+//
-        for ((parameter, arguments) in resolvedCall.valueArguments) {
+//        val callableSymbol = targetDescriptor.toKtCallableSymbol(analysisContext) as? KtFunctionLikeSymbol ?: return null
-            val parameterSymbol = KtFe10DescValueParameterSymbol(parameter, analysisContext)
+//
-
+//        if (resolvedCall is VariableAsFunctionResolvedCall) {
-            for (argument in arguments.arguments) {
+//            val variableDescriptor = resolvedCall.variableCall.candidateDescriptor
-                val expression = argument.getArgumentExpression() ?: continue
+//            val variableSymbol = variableDescriptor.toKtCallableSymbol(analysisContext) as? KtVariableLikeSymbol ?: return null
-                result[expression] = parameterSymbol
+//
-            }
+//            val substitutor = getSubstitutor(resolvedCall.functionCall, resolvedCall.variableCall)
-        }
+//            return if (resolvedCall.functionCall.candidateDescriptor.callableIdIfNotLocal in kotlinFunctionInvokeCallableIds) {
-        return result
+//                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() && (call is KtAnnotationEntry || call.parent is KtAnnotationEntry)) {
+//                return KtAnnotationCall(argumentMapping, getTarget(callableSymbol), token)
+//            }
+//        }
+//
+//        return KtFunctionCall(argumentMapping, getTarget(callableSymbol), getSubstitutor(resolvedCall), token)
+//    }
+//
+//    private fun getUnresolvedCall(call: KtElement): KtCall? {
+//        return when (call) {
+//            is KtSuperTypeCallEntry -> {
+//                val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+//                val target = KtErrorCallTarget(emptyList(), diagnostic, token)
+//                KtDelegatedConstructorCall(LinkedHashMap(), target, KtDelegatedConstructorCallKind.SUPER_CALL, token)
+//            }
+//            is KtConstructorDelegationCall -> {
+//                val diagnostic = KtNonBoundToPsiErrorDiagnostic(factoryName = null, UNRESOLVED_CALL_MESSAGE, token)
+//                val target = KtErrorCallTarget(emptyList(), diagnostic, token)
+//                return KtDelegatedConstructorCall(LinkedHashMap(), target, call.kind, token)
+//            }
+//            else -> null
+//        }
+//    }
+//
+//    private val KtConstructorDelegationCall.kind: KtDelegatedConstructorCallKind
+//        get() = when {
+//            isCallToThis -> KtDelegatedConstructorCallKind.THIS_CALL
+//            else -> KtDelegatedConstructorCallKind.SUPER_CALL
+//        }
+//
+//    private fun createArgumentMapping(resolvedCall: ResolvedCall<*>): LinkedHashMap<KtExpression, KtValueParameterSymbol> {
+//        val result = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
+//        for ((parameter, arguments) in resolvedCall.valueArguments) {
+//            val parameterSymbol = KtFe10DescValueParameterSymbol(parameter, analysisContext)
+//
+//            for (argument in arguments.arguments) {
+//                val expression = argument.getArgumentExpression() ?: continue
+//                result[expression] = parameterSymbol
+//            }
+//        }
+//        return result
+//    }
 }

analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/callResolver/KtFe10ResolveCallTestGenerated.java

@@ -1,698 +0,0 @@
-/*
- * 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.callResolver;
-
-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/callResolver/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/components/callResolver/resolveCall"), Pattern.compile("^(.+)\\.kt$"), null, true);
-    }
-
-    @Test
-    @TestMetadata("annotationEntry.kt")
-    public void testAnnotationEntry() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationEntry.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationInAnnotation_arrayOf.kt")
-    public void testAnnotationInAnnotation_arrayOf() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_arrayOf.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationInAnnotation_collectionLiteral.kt")
-    public void testAnnotationInAnnotation_collectionLiteral() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_collectionLiteral.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationInAnnotation_multipleAnnotations_arrayOf.kt")
-    public void testAnnotationInAnnotation_multipleAnnotations_arrayOf() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_multipleAnnotations_arrayOf.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationInAnnotation_multipleAnnotations_collectionLiteral.kt")
-    public void testAnnotationInAnnotation_multipleAnnotations_collectionLiteral() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_multipleAnnotations_collectionLiteral.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationInAnnotation_noarg.kt")
-    public void testAnnotationInAnnotation_noarg() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_noarg.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationInAnnotation_vararg.kt")
-    public void testAnnotationInAnnotation_vararg() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_vararg.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnDelegate.kt")
-    public void testAnnotationOnDelegate() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnDelegate.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnExpression_asT.kt")
-    public void testAnnotationOnExpression_asT() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_asT.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnExpression_destructuring.kt")
-    public void testAnnotationOnExpression_destructuring() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_destructuring.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnExpression_if.kt")
-    public void testAnnotationOnExpression_if() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_if.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnExpression_whenBranch.kt")
-    public void testAnnotationOnExpression_whenBranch() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_whenBranch.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnFile.kt")
-    public void testAnnotationOnFile() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnFile.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnParameter_param.kt")
-    public void testAnnotationOnParameter_param() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_param.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnParameter_parameterProperty.kt")
-    public void testAnnotationOnParameter_parameterProperty() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_parameterProperty.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnParameter_reified.kt")
-    public void testAnnotationOnParameter_reified() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_reified.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnParameter_setparam.kt")
-    public void testAnnotationOnParameter_setparam() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_setparam.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnProperty_field.kt")
-    public void testAnnotationOnProperty_field() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_field.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnProperty_get.kt")
-    public void testAnnotationOnProperty_get() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_get.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnProperty_property.kt")
-    public void testAnnotationOnProperty_property() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_property.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnProperty_set.kt")
-    public void testAnnotationOnProperty_set() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_set.kt");
-    }
-
-    @Test
-    @TestMetadata("annotationOnReceiver.kt")
-    public void testAnnotationOnReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("arrayOfInAnnotation.kt")
-    public void testArrayOfInAnnotation() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/arrayOfInAnnotation.kt");
-    }
-
-    @Test
-    @TestMetadata("calleeExpressionOfImplicitInvoke.kt")
-    public void testCalleeExpressionOfImplicitInvoke() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/calleeExpressionOfImplicitInvoke.kt");
-    }
-
-    @Test
-    @TestMetadata("checkNotNullCall.kt")
-    public void testCheckNotNullCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/checkNotNullCall.kt");
-    }
-
-    @Test
-    @TestMetadata("checkNotNullCallAsCallee.kt")
-    public void testCheckNotNullCallAsCallee() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/checkNotNullCallAsCallee.kt");
-    }
-
-    @Test
-    @TestMetadata("comparisonCall.kt")
-    public void testComparisonCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/comparisonCall.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignOnVal.kt")
-    public void testCompoundAssignOnVal() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVal.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignOnVal_lhs.kt")
-    public void testCompoundAssignOnVal_lhs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVal_lhs.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignOnVar.kt")
-    public void testCompoundAssignOnVar() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVar.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignOnVar_lhs.kt")
-    public void testCompoundAssignOnVar_lhs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVar_lhs.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignWithArrayAccessConvention.kt")
-    public void testCompoundAssignWithArrayAccessConvention() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayAccessConvention.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignWithArrayAccessConvention_lhs.kt")
-    public void testCompoundAssignWithArrayAccessConvention_lhs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayAccessConvention_lhs.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignWithArrayGetConvention.kt")
-    public void testCompoundAssignWithArrayGetConvention() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayGetConvention.kt");
-    }
-
-    @Test
-    @TestMetadata("compoundAssignWithArrayGetConvention_lhs.kt")
-    public void testCompoundAssignWithArrayGetConvention_lhs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayGetConvention_lhs.kt");
-    }
-
-    @Test
-    @TestMetadata("consecutiveImplicitInvoke1.kt")
-    public void testConsecutiveImplicitInvoke1() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke1.kt");
-    }
-
-    @Test
-    @TestMetadata("consecutiveImplicitInvoke2.kt")
-    public void testConsecutiveImplicitInvoke2() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke2.kt");
-    }
-
-    @Test
-    @TestMetadata("consecutiveImplicitInvoke3.kt")
-    public void testConsecutiveImplicitInvoke3() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke3.kt");
-    }
-
-    @Test
-    @TestMetadata("consecutiveImplicitInvoke_callee.kt")
-    public void testConsecutiveImplicitInvoke_callee() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke_callee.kt");
-    }
-
-    @Test
-    @TestMetadata("delegatedConstructorCall_super.kt")
-    public void testDelegatedConstructorCall_super() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_super.kt");
-    }
-
-    @Test
-    @TestMetadata("delegatedConstructorCall_super_unresolved.kt")
-    public void testDelegatedConstructorCall_super_unresolved() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_super_unresolved.kt");
-    }
-
-    @Test
-    @TestMetadata("delegatedConstructorCall_this.kt")
-    public void testDelegatedConstructorCall_this() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_this.kt");
-    }
-
-    @Test
-    @TestMetadata("delegatedConstructorCall_this_unresolved.kt")
-    public void testDelegatedConstructorCall_this_unresolved() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_this_unresolved.kt");
-    }
-
-    @Test
-    @TestMetadata("enumAsAnnotationValue.kt")
-    public void testEnumAsAnnotationValue() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/enumAsAnnotationValue.kt");
-    }
-
-    @Test
-    @TestMetadata("eqEqCall_fromAny.kt")
-    public void testEqEqCall_fromAny() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/eqEqCall_fromAny.kt");
-    }
-
-    @Test
-    @TestMetadata("eqEqCall_fromSuperType.kt")
-    public void testEqEqCall_fromSuperType() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/eqEqCall_fromSuperType.kt");
-    }
-
-    @Test
-    @TestMetadata("eqEqCall_overridden.kt")
-    public void testEqEqCall_overridden() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/eqEqCall_overridden.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallInTheSameFile.kt")
-    public void testFunctionCallInTheSameFile() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallInTheSameFile.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithExtensionReceiverAndTypeArgument.kt")
-    public void testFunctionCallWithExtensionReceiverAndTypeArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithExtensionReceiverAndTypeArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithLambdaArgument.kt")
-    public void testFunctionCallWithLambdaArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithLambdaArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithNamedArgument.kt")
-    public void testFunctionCallWithNamedArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithNamedArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithNonTrailingLambdaArgument.kt")
-    public void testFunctionCallWithNonTrailingLambdaArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithNonTrailingLambdaArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithSpreadArgument.kt")
-    public void testFunctionCallWithSpreadArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithSpreadArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithTypeArgument.kt")
-    public void testFunctionCallWithTypeArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithTypeArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionCallWithVarargArgument.kt")
-    public void testFunctionCallWithVarargArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithVarargArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("functionTypeVariableCall_dispatchReceiver.kt")
-    public void testFunctionTypeVariableCall_dispatchReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionTypeVariableCall_dispatchReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("functionTypeVariableCall_extensionReceiver.kt")
-    public void testFunctionTypeVariableCall_extensionReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionTypeVariableCall_extensionReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("functionWithReceiverCall.kt")
-    public void testFunctionWithReceiverCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionWithReceiverCall.kt");
-    }
-
-    @Test
-    @TestMetadata("functionWithReceiverSafeCall.kt")
-    public void testFunctionWithReceiverSafeCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionWithReceiverSafeCall.kt");
-    }
-
-    @Test
-    @TestMetadata("hiddenConstructor.kt")
-    public void testHiddenConstructor() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/hiddenConstructor.kt");
-    }
-
-    @Test
-    @TestMetadata("hiddenDeprecated.kt")
-    public void testHiddenDeprecated() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/hiddenDeprecated.kt");
-    }
-
-    @Test
-    @TestMetadata("implicitConstructorDelegationCall.kt")
-    public void testImplicitConstructorDelegationCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/implicitConstructorDelegationCall.kt");
-    }
-
-    @Test
-    @TestMetadata("implicitConstuctorCall.kt")
-    public void testImplicitConstuctorCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/implicitConstuctorCall.kt");
-    }
-
-    @Test
-    @TestMetadata("implicitJavaConstuctorCall.kt")
-    public void testImplicitJavaConstuctorCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/implicitJavaConstuctorCall.kt");
-    }
-
-    @Test
-    @TestMetadata("indexedGet.kt")
-    public void testIndexedGet() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedGet.kt");
-    }
-
-    @Test
-    @TestMetadata("indexedGetWithNotEnoughArgs.kt")
-    public void testIndexedGetWithNotEnoughArgs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedGetWithNotEnoughArgs.kt");
-    }
-
-    @Test
-    @TestMetadata("indexedGetWithTooManyArgs.kt")
-    public void testIndexedGetWithTooManyArgs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedGetWithTooManyArgs.kt");
-    }
-
-    @Test
-    @TestMetadata("indexedSet.kt")
-    public void testIndexedSet() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedSet.kt");
-    }
-
-    @Test
-    @TestMetadata("indexedSetWithNotEnoughArgs.kt")
-    public void testIndexedSetWithNotEnoughArgs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedSetWithNotEnoughArgs.kt");
-    }
-
-    @Test
-    @TestMetadata("indexedSetWithTooManyArgs.kt")
-    public void testIndexedSetWithTooManyArgs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedSetWithTooManyArgs.kt");
-    }
-
-    @Test
-    @TestMetadata("intArrayOfInAnnotation.kt")
-    public void testIntArrayOfInAnnotation() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/intArrayOfInAnnotation.kt");
-    }
-
-    @Test
-    @TestMetadata("javaFunctionCall.kt")
-    public void testJavaFunctionCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaFunctionCall.kt");
-    }
-
-    @Test
-    @TestMetadata("javaPropertyGetter.kt")
-    public void testJavaPropertyGetter() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertyGetter.kt");
-    }
-
-    @Test
-    @TestMetadata("javaPropertyGetter_unqualified.kt")
-    public void testJavaPropertyGetter_unqualified() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertyGetter_unqualified.kt");
-    }
-
-    @Test
-    @TestMetadata("javaPropertyNestedGetter.kt")
-    public void testJavaPropertyNestedGetter() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertyNestedGetter.kt");
-    }
-
-    @Test
-    @TestMetadata("javaPropertySetter.kt")
-    public void testJavaPropertySetter() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertySetter.kt");
-    }
-
-    @Test
-    @TestMetadata("javaPropertySetterIncomplete.kt")
-    public void testJavaPropertySetterIncomplete() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertySetterIncomplete.kt");
-    }
-
-    @Test
-    @TestMetadata("javaPropertySetter_unqualified.kt")
-    public void testJavaPropertySetter_unqualified() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertySetter_unqualified.kt");
-    }
-
-    @Test
-    @TestMetadata("kotlinPropertyGetter.kt")
-    public void testKotlinPropertyGetter() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertyGetter.kt");
-    }
-
-    @Test
-    @TestMetadata("kotlinPropertyGetter_unqualified.kt")
-    public void testKotlinPropertyGetter_unqualified() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertyGetter_unqualified.kt");
-    }
-
-    @Test
-    @TestMetadata("kotlinPropertyNestedGetter.kt")
-    public void testKotlinPropertyNestedGetter() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertyNestedGetter.kt");
-    }
-
-    @Test
-    @TestMetadata("kotlinPropertySetter.kt")
-    public void testKotlinPropertySetter() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertySetter.kt");
-    }
-
-    @Test
-    @TestMetadata("kotlinPropertySetter_unqualified.kt")
-    public void testKotlinPropertySetter_unqualified() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertySetter_unqualified.kt");
-    }
-
-    @Test
-    @TestMetadata("memberFunctionCallWithTypeArgument.kt")
-    public void testMemberFunctionCallWithTypeArgument() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/memberFunctionCallWithTypeArgument.kt");
-    }
-
-    @Test
-    @TestMetadata("postfixUnaryOperatorOnVar.kt")
-    public void testPostfixUnaryOperatorOnVar() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorOnVar.kt");
-    }
-
-    @Test
-    @TestMetadata("postfixUnaryOperatorOnVar_base.kt")
-    public void testPostfixUnaryOperatorOnVar_base() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorOnVar_base.kt");
-    }
-
-    @Test
-    @TestMetadata("postfixUnaryOperatorWithArrayAccessConvention.kt")
-    public void testPostfixUnaryOperatorWithArrayAccessConvention() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorWithArrayAccessConvention.kt");
-    }
-
-    @Test
-    @TestMetadata("postfixUnaryOperatorWithArrayAccessConvention_base.kt")
-    public void testPostfixUnaryOperatorWithArrayAccessConvention_base() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorWithArrayAccessConvention_base.kt");
-    }
-
-    @Test
-    @TestMetadata("prefixUnaryOperatorOnVar.kt")
-    public void testPrefixUnaryOperatorOnVar() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorOnVar.kt");
-    }
-
-    @Test
-    @TestMetadata("prefixUnaryOperatorOnVar_base.kt")
-    public void testPrefixUnaryOperatorOnVar_base() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorOnVar_base.kt");
-    }
-
-    @Test
-    @TestMetadata("prefixUnaryOperatorWithArrayAccessConvention.kt")
-    public void testPrefixUnaryOperatorWithArrayAccessConvention() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorWithArrayAccessConvention.kt");
-    }
-
-    @Test
-    @TestMetadata("prefixUnaryOperatorWithArrayAccessConvention_base.kt")
-    public void testPrefixUnaryOperatorWithArrayAccessConvention_base() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorWithArrayAccessConvention_base.kt");
-    }
-
-    @Test
-    @TestMetadata("privateMember.kt")
-    public void testPrivateMember() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/privateMember.kt");
-    }
-
-    @Test
-    @TestMetadata("qualifiedCalleeExpressionOfImplicitInvoke.kt")
-    public void testQualifiedCalleeExpressionOfImplicitInvoke() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/qualifiedCalleeExpressionOfImplicitInvoke.kt");
-    }
-
-    @Test
-    @TestMetadata("resolveCallInSuperConstructorParam.kt")
-    public void testResolveCallInSuperConstructorParam() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/resolveCallInSuperConstructorParam.kt");
-    }
-
-    @Test
-    @TestMetadata("samConstructorCall.kt")
-    public void testSamConstructorCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/samConstructorCall.kt");
-    }
-
-    @Test
-    @TestMetadata("simpleCallWithNonMatchingArgs.kt")
-    public void testSimpleCallWithNonMatchingArgs() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/simpleCallWithNonMatchingArgs.kt");
-    }
-
-    @Test
-    @TestMetadata("smartCastExplicitReceiver.kt")
-    public void testSmartCastExplicitReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/smartCastExplicitReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("smartCastImplicitReceiver.kt")
-    public void testSmartCastImplicitReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/smartCastImplicitReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("unresolvedSuperReference.kt")
-    public void testUnresolvedSuperReference() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvedSuperReference.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunction.kt")
-    public void testVariableAsFunction() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunction.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionLikeCall.kt")
-    public void testVariableAsFunctionLikeCall() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionLikeCall.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionWithParameterName.kt")
-    public void testVariableAsFunctionWithParameterName() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterName.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionWithParameterNameAnnotation.kt")
-    public void testVariableAsFunctionWithParameterNameAnnotation() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameAnnotation.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionWithParameterNameAnnotationConflict.kt")
-    public void testVariableAsFunctionWithParameterNameAnnotationConflict() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionWithParameterNameGeneric.kt")
-    public void testVariableAsFunctionWithParameterNameGeneric() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameGeneric.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionWithParameterNameInNonFunctionType.kt")
-    public void testVariableAsFunctionWithParameterNameInNonFunctionType() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameInNonFunctionType.kt");
-    }
-
-    @Test
-    @TestMetadata("variableAsFunctionWithParameterNameMixed.kt")
-    public void testVariableAsFunctionWithParameterNameMixed() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameMixed.kt");
-    }
-
-    @Test
-    @TestMetadata("variableWithExtensionInvoke.kt")
-    public void testVariableWithExtensionInvoke() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithExtensionInvoke.kt");
-    }
-
-    @Test
-    @TestMetadata("variableWithInvokeFunctionCall_dispatchReceiver.kt")
-    public void testVariableWithInvokeFunctionCall_dispatchReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithInvokeFunctionCall_dispatchReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("variableWithInvokeFunctionCall_extensionReceiver.kt")
-    public void testVariableWithInvokeFunctionCall_extensionReceiver() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithInvokeFunctionCall_extensionReceiver.kt");
-    }
-
-    @Test
-    @TestMetadata("variableWithMemberInvoke.kt")
-    public void testVariableWithMemberInvoke() throws Exception {
-        runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithMemberInvoke.kt");
-    }
-}

generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt

@@ -5,10 +5,8 @@
 
 package org.jetbrains.kotlin.generators.tests.analysis.api
 
-import org.jetbrains.kotlin.analysis.api.descriptors.test.annotations.AbstractAnalysisApiFE10AnnotationsOnFilesTest
 import org.jetbrains.kotlin.analysis.api.descriptors.test.annotations.AbstractAnalysisApiFe10AnnotationsOnDeclarationsTest
 import org.jetbrains.kotlin.analysis.api.descriptors.test.annotations.AbstractAnalysisApiFe10AnnotationsOnTypesTest
-import org.jetbrains.kotlin.analysis.api.descriptors.test.components.callResolver.AbstractKtFe10ResolveCallTest
 import org.jetbrains.kotlin.analysis.api.descriptors.test.components.compileTimeConstantProvider.AbstractKtFe10CompileTimeConstantEvaluatorTest
 import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionInfoProvider.AbstractKtFe10ReturnTargetSymbolTest
 import org.jetbrains.kotlin.analysis.api.descriptors.test.components.expressionInfoProvider.AbstractKtFe10WhenMissingCasesTest
@@ -46,8 +44,8 @@ import org.jetbrains.kotlin.analysis.api.fir.components.typeProvider.AbstractFir
 import org.jetbrains.kotlin.analysis.api.fir.components.typeProvider.AbstractFirHasCommonSubtypeTest
 import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirDelegateMemberScopeTest
 import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirFileScopeTest
-import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirSubstitutionOverridesUnwrappingTest
 import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirMemberScopeByFqNameTest
+import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirSubstitutionOverridesUnwrappingTest
 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
@@ -148,7 +146,9 @@ private fun TestGroupSuite.generateAnalysisApiNonComponentsTests() {
 private fun TestGroupSuite.generateAnalysisApiComponentsTests() {
     component("callResolver") {
         test(
-            fir = AbstractFirResolveCallTest::class, fe10 = AbstractKtFe10ResolveCallTest::class,
+            fir = AbstractFirResolveCallTest::class,
+            // TODO: re-enable after KtFe10CallResolver is properly implemented
+            fe10 = null // AbstractKtFe10ResolveCallTest::class,
         ) {
             model("resolveCall")
         }