diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt index 4c0f5d58a87..95699284603 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt @@ -7,11 +7,14 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components import com.intellij.psi.PsiElement import org.jetbrains.kotlin.analysis.api.components.KtExpressionTypeProvider +import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext 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.base.toKtType import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken +import org.jetbrains.kotlin.analysis.api.types.KtErrorType +import org.jetbrains.kotlin.analysis.api.types.KtFunctionalType import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.diagnostics.Errors @@ -28,6 +31,7 @@ import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall import org.jetbrains.kotlin.resolve.calls.util.getType import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor import org.jetbrains.kotlin.resolve.sam.getFunctionTypeForAbstractMethod +import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.checker.intersectWrappedTypes import org.jetbrains.kotlin.types.error.ErrorTypeKind @@ -181,44 +185,83 @@ class KtFe10ExpressionTypeProvider( } } - if (parentExpression is KtCallableDeclaration) { - if (expression is KtBlockExpression) { - return null + when (parentExpression) { + is KtCallableDeclaration -> { + if (expression is KtBlockExpression) { + return null + } + + val bindingContext = analysisContext.analyze(parentExpression) + val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, parentExpression] + if (descriptor is CallableDescriptor) { + return descriptor.returnType?.toKtNonErrorType(analysisContext) + } } - val bindingContext = analysisContext.analyze(parentExpression) - val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, parentExpression] - if (descriptor is CallableDescriptor) { - return descriptor.returnType?.toKtType(analysisContext) - } - } else if (parentExpression is KtBinaryExpressionWithTypeRHS && KtPsiUtil.isCast(parentExpression)) { - val typeReference = parentExpression.right - if (typeReference != null) { - val bindingContext = analysisContext.analyze(typeReference) - var kotlinType = bindingContext[BindingContext.TYPE, typeReference] - if (kotlinType != null && KtPsiUtil.isSafeCast(parentExpression)) { - kotlinType = kotlinType.makeNullable() + is KtBinaryExpressionWithTypeRHS -> { + val typeReference = parentExpression.right + if (KtPsiUtil.isCast(parentExpression) && typeReference != null) { + val bindingContext = analysisContext.analyze(typeReference) + var kotlinType = bindingContext[BindingContext.TYPE, typeReference] + if (kotlinType != null && KtPsiUtil.isSafeCast(parentExpression)) { + kotlinType = kotlinType.makeNullable() + } + return kotlinType?.toKtNonErrorType(analysisContext) } - return kotlinType?.toKtType(analysisContext) } - } else if (parentExpression is KtValueArgument) { - val callExpression = getContainingCallExpression(parentExpression) - if (callExpression != null) { - val bindingContext = analysisContext.analyze(callExpression) - val resolvedCall = callExpression.getResolvedCall(bindingContext) - if (resolvedCall != null) { - val parameterDescriptor = resolvedCall.getParameterForArgument(parentExpression)?.original - if (parameterDescriptor != null) { - val kotlinType = when (val originalCallableDescriptor = parameterDescriptor.containingDeclaration) { - is SamConstructorDescriptor -> originalCallableDescriptor.returnTypeOrNothing - else -> { - if (parameterDescriptor.isVararg) - parameterDescriptor.varargElementType - else - parameterDescriptor.type + + is KtValueArgument -> { + val callExpression = getContainingCallExpression(parentExpression) + if (callExpression != null) { + val bindingContext = analysisContext.analyze(callExpression) + val resolvedCall = callExpression.getResolvedCall(bindingContext) + if (resolvedCall != null) { + val parameterDescriptor = resolvedCall.getParameterForArgument(parentExpression)?.original + if (parameterDescriptor != null) { + val kotlinType = when (val originalCallableDescriptor = parameterDescriptor.containingDeclaration) { + is SamConstructorDescriptor -> originalCallableDescriptor.returnTypeOrNothing + else -> { + if (parameterDescriptor.isVararg) + parameterDescriptor.varargElementType + else + parameterDescriptor.type + } } + return kotlinType?.toKtNonErrorType(analysisContext) } - return kotlinType?.toKtType(analysisContext) + } + } + } + + is KtWhenConditionWithExpression -> { + val whenExpression = (parentExpression.parent as? KtWhenEntry)?.parent as? KtWhenExpression + if (whenExpression != null) { + val subject = whenExpression.subjectExpression ?: return with(analysisSession) { builtinTypes.BOOLEAN } + val kotlinType = analysisContext.analyze(subject).getType(subject) + return kotlinType?.toKtNonErrorType(analysisContext) + } + } + + is KtBlockExpression -> { + if (expression == parentExpression.statements.lastOrNull()) { + val functionLiteral = parentExpression.parent as? KtFunctionLiteral + if (functionLiteral != null) { + val functionalType = getExpectedType(functionLiteral) as? KtFunctionalType + functionalType?.returnType?.let { return it } + } + } + } + + is KtWhenEntry -> { + if (expression == parentExpression.expression) { + val whenExpression = parentExpression.parent as? KtWhenExpression + if (whenExpression != null) { + getExpectedType(whenExpression)?.let { return it } + + val entries = whenExpression.entries + val entryExpressions = entries.mapNotNull { entry -> entry.expression?.takeUnless { expression == it } } + val kotlinTypes = entryExpressions.mapNotNull { analysisContext.analyze(it).getType(it) } + return intersectWrappedTypes(kotlinTypes).toKtNonErrorType(analysisContext) } } } @@ -226,7 +269,7 @@ class KtFe10ExpressionTypeProvider( val bindingContext = analysisContext.analyze(ktExpression) val kotlinType = bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, ktExpression] - return kotlinType?.toKtType(analysisContext) + return kotlinType?.toKtNonErrorType(analysisContext) } private fun getContainingCallExpression(argument: KtValueArgument): KtCallExpression? { @@ -274,4 +317,7 @@ class KtFe10ExpressionTypeProvider( val expressionType = expression.getType(bindingContext) ?: return false return !TypeUtils.isNullableType(expressionType) } + + private fun KotlinType.toKtNonErrorType(analysisContext: Fe10AnalysisContext): KtType? = + this.toKtType(analysisContext).takeUnless { it is KtErrorType } } \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java index 2c3e8d40a05..dddc9c1c249 100644 --- a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java @@ -41,11 +41,77 @@ public class Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerate ); } + @Test + @TestMetadata("afterExclOperand.kt") + public void testAfterExclOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt"); + } + @Test public void testAllFilesPresentInExpectedExpressionType() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("arrayAccessExpressionGet.kt") + public void testArrayAccessExpressionGet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionGetWithTypeParameters.kt") + public void testArrayAccessExpressionGetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSet.kt") + public void testArrayAccessExpressionSet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSetWithTypeParameters.kt") + public void testArrayAccessExpressionSetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithSubject.kt") + public void testConditionInWhenWithSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithoutSubject.kt") + public void testConditionInWhenWithoutSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperand.kt") + public void testElvisExpressionLeftOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperandWithoutExplicitType.kt") + public void testElvisExpressionLeftOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperand.kt") + public void testElvisExpressionRightOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperandWithoutExplicitType.kt") + public void testElvisExpressionRightOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt"); + } + @Test @TestMetadata("functionExpressionBody.kt") public void testFunctionExpressionBody() throws Exception { @@ -136,6 +202,12 @@ public class Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerate runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionParamQualified.kt"); } + @Test + @TestMetadata("infixFunctionTypeParameter.kt") + public void testInfixFunctionTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt"); + } + @Test @TestMetadata("lambdaWithExplicitTypeFromVariable.kt") public void testLambdaWithExplicitTypeFromVariable() throws Exception { @@ -148,6 +220,42 @@ public class Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerate runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lambdaWithoutReturnNorExplicitType.kt"); } + @Test + @TestMetadata("lastStatementInFunctionBlockBody.kt") + public void testLastStatementInFunctionBlockBody() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt"); + } + + @Test + @TestMetadata("lastStatementInLambda.kt") + public void testLastStatementInLambda() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithTypeMismatch.kt") + public void testLastStatementInLambdaWithTypeMismatch() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithoutExplicitType.kt") + public void testLastStatementInLambdaWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("lastStatementInTry.kt") + public void testLastStatementInTry() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt"); + } + + @Test + @TestMetadata("lastStatementInTryWithoutExplicitType.kt") + public void testLastStatementInTryWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt"); + } + @Test @TestMetadata("propertyDeclaration.kt") public void testPropertyDeclaration() throws Exception { @@ -274,6 +382,42 @@ public class Fe10IdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerate runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samWithTypeCast.kt"); } + @Test + @TestMetadata("statementInIf.kt") + public void testStatementInIf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt"); + } + + @Test + @TestMetadata("statementInIfBlockExpression.kt") + public void testStatementInIfBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInIfWithoutExplicitType.kt") + public void testStatementInIfWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("statementInWhen.kt") + public void testStatementInWhen() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt"); + } + + @Test + @TestMetadata("statementInWhenBlockExpression.kt") + public void testStatementInWhenBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInWhenWithoutExplicitType.kt") + public void testStatementInWhenWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt"); + } + @Test @TestMetadata("variableAssignment.kt") public void testVariableAssignment() throws Exception { diff --git a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java index 4d703167b38..a1bd95e26dc 100644 --- a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/expressionTypeProvider/Fe10IdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java @@ -277,6 +277,12 @@ public class Fe10IdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated exte runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetUnresovledSet.kt"); } + @Test + @TestMetadata("arrayAssignmentTargetWithTypeParameters.kt") + public void testArrayAssignmentTargetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt"); + } + @Test @TestMetadata("arrayCompoundAssignementTarget.kt") public void testArrayCompoundAssignementTarget() throws Exception { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirAnalysisSessionComponent.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirAnalysisSessionComponent.kt index 5c6e054603a..89adad0997a 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirAnalysisSessionComponent.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirAnalysisSessionComponent.kt @@ -79,26 +79,36 @@ internal interface KtFirAnalysisSessionComponent { ) } - fun FirQualifiedAccessExpression.createSubstitutorFromTypeArguments(): KtSubstitutor? { - return createConeSubstitutorFromTypeArguments()?.toKtSubstitutor() + fun FirQualifiedAccessExpression.createSubstitutorFromTypeArguments(discardErrorTypes: Boolean = false): KtSubstitutor? { + return createConeSubstitutorFromTypeArguments(discardErrorTypes)?.toKtSubstitutor() } - fun FirQualifiedAccessExpression.createSubstitutorFromTypeArguments(callableSymbol: FirCallableSymbol<*>): KtSubstitutor { - return createConeSubstitutorFromTypeArguments(callableSymbol).toKtSubstitutor() + fun FirQualifiedAccessExpression.createSubstitutorFromTypeArguments( + callableSymbol: FirCallableSymbol<*>, + discardErrorTypes: Boolean = false + ): KtSubstitutor { + return createConeSubstitutorFromTypeArguments(callableSymbol, discardErrorTypes).toKtSubstitutor() } - fun FirQualifiedAccessExpression.createConeSubstitutorFromTypeArguments(): ConeSubstitutor? { + fun FirQualifiedAccessExpression.createConeSubstitutorFromTypeArguments(discardErrorTypes: Boolean = false): ConeSubstitutor? { val symbol = calleeReference.toResolvedCallableSymbol() ?: return null - return createConeSubstitutorFromTypeArguments(symbol) + return createConeSubstitutorFromTypeArguments(symbol, discardErrorTypes) } - fun FirQualifiedAccessExpression.createConeSubstitutorFromTypeArguments(callableSymbol: FirCallableSymbol<*>): ConeSubstitutor { + /** + * @param discardErrorTypes if true, then type arguments with error types are not added in substitution map + */ + fun FirQualifiedAccessExpression.createConeSubstitutorFromTypeArguments( + callableSymbol: FirCallableSymbol<*>, + discardErrorTypes: Boolean = false + ): ConeSubstitutor { val typeArgumentMap = buildMap { // Type arguments are ignored defensively if `callableSymbol` can't provide enough type parameters (and vice versa). For // example, when call candidates are collected, the candidate's `callableSymbol` might have fewer type parameters than the // inferred call's type arguments. typeArguments.zip(callableSymbol.typeParameterSymbols).forEach { (typeArgument, typeParameterSymbol) -> val type = typeArgument.safeAs()?.typeRef?.coneType ?: return@forEach + if (type is ConeErrorType && discardErrorTypes) return@forEach put(typeParameterSymbol, type) } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt index 81b45c80513..25d3ada387c 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt @@ -11,6 +11,8 @@ import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.utils.getReferencedElementType import org.jetbrains.kotlin.analysis.api.fir.utils.unwrap import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken +import org.jetbrains.kotlin.analysis.api.types.KtErrorType +import org.jetbrains.kotlin.analysis.api.types.KtFunctionalType import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType @@ -23,11 +25,13 @@ import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.resolve.constructFunctionType +import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.utils.addToStdlib.applyIf import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract @@ -92,8 +96,19 @@ internal class KtFirExpressionTypeProvider( val assignment = expression.parent as? KtBinaryExpression ?: return null if (assignment.operationToken !in KtTokens.ALL_ASSIGNMENTS) return null if (assignment.left != expression) return null - val setTargetArgumentParameter = fir.resolvedArgumentMapping?.entries?.last()?.value ?: return null - return setTargetArgumentParameter.returnTypeRef.coneType.asKtType() + val setTargetParameterType = fir.argumentsToSubstitutedValueParameters()?.values?.last()?.substitutedType ?: return null + return setTargetParameterType.asKtType() + } + + private data class SubstitutedValueParameter(val parameter: FirValueParameter, val substitutedType: ConeKotlinType) + + private fun FirFunctionCall.argumentsToSubstitutedValueParameters( + substituteWithErrorTypes: Boolean = true + ): LinkedHashMap? { + val substitutor = createConeSubstitutorFromTypeArguments(discardErrorTypes = !substituteWithErrorTypes) ?: ConeSubstitutor.Empty + return resolvedArgumentMapping?.mapValuesTo(LinkedHashMap()) { (_, parameter) -> + SubstitutedValueParameter(parameter, substitutor.substituteOrSelf(parameter.returnTypeRef.coneType)) + } } override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType { @@ -134,10 +149,17 @@ internal class KtFirExpressionTypeProvider( ?: getExpressionTypeByIfOrBooleanCondition(unwrapped) ?: getExpectedTypeByTypeCast(unwrapped) ?: getExpectedTypeOfFunctionParameter(unwrapped) + ?: getExpectedTypeOfIndexingParameter(unwrapped) ?: getExpectedTypeOfInfixFunctionParameter(unwrapped) ?: getExpectedTypeByVariableAssignment(unwrapped) ?: getExpectedTypeByPropertyDeclaration(unwrapped) ?: getExpectedTypeByFunctionExpressionBody(unwrapped) + ?: getExpectedTypeOfLastStatementInBlock(unwrapped) + ?: getExpectedTypeByIfExpression(unwrapped) + ?: getExpectedTypeOfWhenEntryExpression(unwrapped) + ?: getExpectedTypeByTryExpression(unwrapped) + ?: getExpectedTypeOfElvisOperand(unwrapped) + ?: getExpectedTypeByWhenEntryValue(unwrapped) return expectedType } @@ -158,9 +180,9 @@ internal class KtFirExpressionTypeProvider( return (callee.fir as FirSimpleFunction).returnTypeRef.coneType.asKtType() } - val arguments = firCall.resolvedArgumentMapping ?: return null - val firParameterForExpression = - arguments.entries.firstOrNull { (arg, _) -> + val argumentsToParameters = firCall.argumentsToSubstitutedValueParameters(substituteWithErrorTypes = false) ?: return null + val (firParameterForExpression, substitutedType) = + argumentsToParameters.entries.firstOrNull { (arg, _) -> when (arg) { // TODO: better to utilize. See `createArgumentMapping` in [KtFirCallResolver] is FirLambdaArgumentExpression, is FirNamedArgumentExpression, is FirSpreadArgumentExpression -> @@ -169,11 +191,29 @@ internal class KtFirExpressionTypeProvider( arg.psi == argumentExpression } }?.value ?: return null - val coneType = firParameterForExpression.returnTypeRef.coneType return if (firParameterForExpression.isVararg) - coneType.varargElementType().asKtType() + substitutedType.varargElementType().asKtType() else - coneType.asKtType() + substitutedType.asKtType() + } + + /** + * Expected type of the indexing parameter in array access, for example, in the following code: + * ``` + * val map = mapOf() + * map[k] = v + * ``` + * `k` is indexing parameter and its expected type is `Int`. + */ + private fun getExpectedTypeOfIndexingParameter(expression: PsiElement): KtType? { + val arrayAccessExpression = expression.unwrapQualified { arrayAccessExpression, currentExpression -> + currentExpression in arrayAccessExpression.indexExpressions + } ?: return null + val firCall = arrayAccessExpression.getOrBuildFirSafe(firResolveSession) ?: return null + val firArgument = firCall.argumentList.arguments.firstOrNull { it.psi == expression } ?: return null + + val argumentsToParameters = firCall.argumentsToSubstitutedValueParameters(substituteWithErrorTypes = false) ?: return null + return argumentsToParameters[firArgument]?.substitutedType?.asKtType() } private fun PsiElement.getFunctionCallAsWithThisAsParameter(): KtCallWithArgument? { @@ -196,9 +236,8 @@ internal class KtFirExpressionTypeProvider( val firCall = infixCallExpression.getOrBuildFirSafe(firResolveSession) ?: return null // There is only one parameter for infix functions; get its type - val arguments = firCall.resolvedArgumentMapping ?: return null - val firParameterForExpression = arguments.values.singleOrNull() ?: return null - return firParameterForExpression.returnTypeRef.coneType.asKtType() + val argumentsToParameters = firCall.argumentsToSubstitutedValueParameters(substituteWithErrorTypes = false) ?: return null + return argumentsToParameters.values.singleOrNull()?.substitutedType?.asKtType() ?: return null } private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { @@ -222,14 +261,14 @@ internal class KtFirExpressionTypeProvider( expression.unwrapQualified { binaryExpr, expr -> binaryExpr.right == expr && binaryExpr.operationToken == KtTokens.EQ } ?: return null val variableExpression = assignmentExpression.left as? KtNameReferenceExpression ?: return null - return getKtExpressionType(variableExpression) + return getKtExpressionNonErrorType(variableExpression) } private fun getExpectedTypeByPropertyDeclaration(expression: PsiElement): KtType? { // Given: `val x: T = expression` // Expected type of `expression` is `T` val property = expression.unwrapQualified { property, expr -> property.initializer == expr } ?: return null - return getReturnTypeForKtDeclaration(property) + return getReturnTypeForKtDeclaration(property).nonErrorTypeOrNull() } private fun getExpectedTypeByFunctionExpressionBody(expression: PsiElement): KtType? { @@ -241,9 +280,91 @@ internal class KtFirExpressionTypeProvider( // which may raise an exception if we attempt to retrieve, e.g., callable declaration from it. return null } - return getReturnTypeForKtDeclaration(function) + return getReturnTypeForKtDeclaration(function).nonErrorTypeOrNull() } + private fun getExpectedTypeOfLastStatementInBlock(expression: PsiElement): KtType? { + val blockExpression = expression.unwrapQualified { blockExpression, currentExpression -> + currentExpression == blockExpression.statements.lastOrNull() + } ?: return null + + val functionLiteral = blockExpression.parent as? KtFunctionLiteral + return if (functionLiteral != null) { + val functionalType = getExpectedType(functionLiteral) as? KtFunctionalType + functionalType?.returnType + } else { + getExpectedType(blockExpression) + } + } + + private fun getExpectedTypeByIfExpression(expression: PsiElement): KtType? { + val ifExpression = expression.unwrapQualified { ifExpression, currentExpression -> + currentExpression == ifExpression.then || currentExpression == ifExpression.`else` + } ?: return null + getExpectedType(ifExpression)?.let { return it } + + // if `KtIfExpression` doesn't have an expected type, get the expected type of the current branch from the other branch + val otherBranch = (if (expression == ifExpression.then) ifExpression.`else` else ifExpression.then) ?: return null + return getKtExpressionNonErrorType(otherBranch) + } + + private fun getExpectedTypeOfWhenEntryExpression(expression: PsiElement): KtType? { + val whenEntry = expression.unwrapQualified { whenEntry, currentExpression -> + currentExpression == whenEntry.expression + } ?: return null + val whenExpression = whenEntry.parent as? KtWhenExpression ?: return null + getExpectedType(whenExpression)?.let { return it } + + // if `KtWhenExpression` doesn't have an expected type, get the expected type of the current entry from the other entries + val entryExpressions = whenExpression.entries + .mapNotNull { it.expression } + .filter { entryExpression -> entryExpression != expression } + val types = entryExpressions.mapNotNull { getKtExpressionNonErrorType(it) } + return analysisSession.useSiteSession.typeContext.intersectTypesOrNull(types.map { it.coneType })?.asKtType() + } + + private fun getExpectedTypeByTryExpression(expression: PsiElement): KtType? { + val tryExpression = expression.unwrapQualified { tryExpression, currentExpression -> + currentExpression == tryExpression.tryBlock + } ?: return null + return getExpectedType(tryExpression) + } + + private fun getExpectedTypeOfElvisOperand(expression: PsiElement): KtType? { + val binaryExpression = expression.unwrapQualified { binaryExpression, operand -> + binaryExpression.operationToken == KtTokens.ELVIS && (operand == binaryExpression.left || operand == binaryExpression.right) + } ?: return null + if (expression !is KtExpression) return null + val type = getExpectedType(binaryExpression) ?: getElvisOperandExpectedTypeByOtherOperand(expression, binaryExpression) + + return type?.applyIf(expression == binaryExpression.left) { withNullability(ConeNullability.NULLABLE) } + } + + private fun getElvisOperandExpectedTypeByOtherOperand(operand: KtExpression, elvisExpression: KtBinaryExpression): KtType? { + val leftOperand = elvisExpression.left ?: return null + val rightOperand = elvisExpression.right ?: return null + return if (operand == leftOperand) { + getKtExpressionNonErrorType(rightOperand) + } else { + getKtExpressionNonErrorType(leftOperand)?.withNullability(ConeNullability.NOT_NULL) + } + } + + private fun KtType.withNullability(nullability: ConeNullability): KtType = + coneType.withNullability(nullability, analysisSession.useSiteSession.typeContext).asKtType() + + private fun getExpectedTypeByWhenEntryValue(expression: PsiElement): KtType? { + val condition = expression.parent as? KtWhenConditionWithExpression ?: return null + val whenExpression = (condition.parent as? KtWhenEntry)?.parent as? KtWhenExpression ?: return null + val subject = whenExpression.subjectExpression ?: return with(analysisSession) { builtinTypes.BOOLEAN } + return getKtExpressionNonErrorType(subject) + } + + private fun getKtExpressionNonErrorType(expression: KtExpression): KtType? = + getKtExpressionType(expression)?.nonErrorTypeOrNull() + + private fun KtType.nonErrorTypeOrNull(): KtType? = takeUnless { it is KtErrorType } + private fun PsiElement.isWhileLoopCondition() = unwrapQualified { whileExpr, cond -> whileExpr.condition == cond } != null diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java index 9794048ce3f..647afc0b70b 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java @@ -41,11 +41,77 @@ public class FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenera ); } + @Test + @TestMetadata("afterExclOperand.kt") + public void testAfterExclOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt"); + } + @Test public void testAllFilesPresentInExpectedExpressionType() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("arrayAccessExpressionGet.kt") + public void testArrayAccessExpressionGet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionGetWithTypeParameters.kt") + public void testArrayAccessExpressionGetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSet.kt") + public void testArrayAccessExpressionSet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSetWithTypeParameters.kt") + public void testArrayAccessExpressionSetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithSubject.kt") + public void testConditionInWhenWithSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithoutSubject.kt") + public void testConditionInWhenWithoutSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperand.kt") + public void testElvisExpressionLeftOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperandWithoutExplicitType.kt") + public void testElvisExpressionLeftOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperand.kt") + public void testElvisExpressionRightOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperandWithoutExplicitType.kt") + public void testElvisExpressionRightOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt"); + } + @Test @TestMetadata("functionExpressionBody.kt") public void testFunctionExpressionBody() throws Exception { @@ -136,6 +202,12 @@ public class FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenera runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionParamQualified.kt"); } + @Test + @TestMetadata("infixFunctionTypeParameter.kt") + public void testInfixFunctionTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt"); + } + @Test @TestMetadata("lambdaWithExplicitTypeFromVariable.kt") public void testLambdaWithExplicitTypeFromVariable() throws Exception { @@ -148,6 +220,42 @@ public class FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenera runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lambdaWithoutReturnNorExplicitType.kt"); } + @Test + @TestMetadata("lastStatementInFunctionBlockBody.kt") + public void testLastStatementInFunctionBlockBody() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt"); + } + + @Test + @TestMetadata("lastStatementInLambda.kt") + public void testLastStatementInLambda() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithTypeMismatch.kt") + public void testLastStatementInLambdaWithTypeMismatch() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithoutExplicitType.kt") + public void testLastStatementInLambdaWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("lastStatementInTry.kt") + public void testLastStatementInTry() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt"); + } + + @Test + @TestMetadata("lastStatementInTryWithoutExplicitType.kt") + public void testLastStatementInTryWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt"); + } + @Test @TestMetadata("propertyDeclaration.kt") public void testPropertyDeclaration() throws Exception { @@ -274,6 +382,42 @@ public class FirIdeDependentAnalysisSourceModuleExpectedExpressionTypeTestGenera runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samWithTypeCast.kt"); } + @Test + @TestMetadata("statementInIf.kt") + public void testStatementInIf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt"); + } + + @Test + @TestMetadata("statementInIfBlockExpression.kt") + public void testStatementInIfBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInIfWithoutExplicitType.kt") + public void testStatementInIfWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("statementInWhen.kt") + public void testStatementInWhen() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt"); + } + + @Test + @TestMetadata("statementInWhenBlockExpression.kt") + public void testStatementInWhenBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInWhenWithoutExplicitType.kt") + public void testStatementInWhenWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt"); + } + @Test @TestMetadata("variableAssignment.kt") public void testVariableAssignment() throws Exception { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleHLExpressionTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleHLExpressionTypeTestGenerated.java index d4bcb39e564..c5d03993b08 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleHLExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeDependentAnalysisSourceModuleHLExpressionTypeTestGenerated.java @@ -277,6 +277,12 @@ public class FirIdeDependentAnalysisSourceModuleHLExpressionTypeTestGenerated ex runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetUnresovledSet.kt"); } + @Test + @TestMetadata("arrayAssignmentTargetWithTypeParameters.kt") + public void testArrayAssignmentTargetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt"); + } + @Test @TestMetadata("arrayCompoundAssignementTarget.kt") public void testArrayCompoundAssignementTarget() throws Exception { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java index fce605a1e45..6283464485e 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java @@ -41,11 +41,77 @@ public class FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated ); } + @Test + @TestMetadata("afterExclOperand.kt") + public void testAfterExclOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt"); + } + @Test public void testAllFilesPresentInExpectedExpressionType() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("arrayAccessExpressionGet.kt") + public void testArrayAccessExpressionGet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionGetWithTypeParameters.kt") + public void testArrayAccessExpressionGetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSet.kt") + public void testArrayAccessExpressionSet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSetWithTypeParameters.kt") + public void testArrayAccessExpressionSetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithSubject.kt") + public void testConditionInWhenWithSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithoutSubject.kt") + public void testConditionInWhenWithoutSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperand.kt") + public void testElvisExpressionLeftOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperandWithoutExplicitType.kt") + public void testElvisExpressionLeftOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperand.kt") + public void testElvisExpressionRightOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperandWithoutExplicitType.kt") + public void testElvisExpressionRightOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt"); + } + @Test @TestMetadata("functionExpressionBody.kt") public void testFunctionExpressionBody() throws Exception { @@ -136,6 +202,12 @@ public class FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionParamQualified.kt"); } + @Test + @TestMetadata("infixFunctionTypeParameter.kt") + public void testInfixFunctionTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt"); + } + @Test @TestMetadata("lambdaWithExplicitTypeFromVariable.kt") public void testLambdaWithExplicitTypeFromVariable() throws Exception { @@ -148,6 +220,42 @@ public class FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lambdaWithoutReturnNorExplicitType.kt"); } + @Test + @TestMetadata("lastStatementInFunctionBlockBody.kt") + public void testLastStatementInFunctionBlockBody() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt"); + } + + @Test + @TestMetadata("lastStatementInLambda.kt") + public void testLastStatementInLambda() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithTypeMismatch.kt") + public void testLastStatementInLambdaWithTypeMismatch() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithoutExplicitType.kt") + public void testLastStatementInLambdaWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("lastStatementInTry.kt") + public void testLastStatementInTry() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt"); + } + + @Test + @TestMetadata("lastStatementInTryWithoutExplicitType.kt") + public void testLastStatementInTryWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt"); + } + @Test @TestMetadata("propertyDeclaration.kt") public void testPropertyDeclaration() throws Exception { @@ -274,6 +382,42 @@ public class FirIdeNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samWithTypeCast.kt"); } + @Test + @TestMetadata("statementInIf.kt") + public void testStatementInIf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt"); + } + + @Test + @TestMetadata("statementInIfBlockExpression.kt") + public void testStatementInIfBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInIfWithoutExplicitType.kt") + public void testStatementInIfWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("statementInWhen.kt") + public void testStatementInWhen() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt"); + } + + @Test + @TestMetadata("statementInWhenBlockExpression.kt") + public void testStatementInWhenBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInWhenWithoutExplicitType.kt") + public void testStatementInWhenWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt"); + } + @Test @TestMetadata("variableAssignment.kt") public void testVariableAssignment() throws Exception { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java index 43b0d8c0592..9517a26781f 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/expressionTypeProvider/FirIdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java @@ -277,6 +277,12 @@ public class FirIdeNormalAnalysisSourceModuleHLExpressionTypeTestGenerated exten runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetUnresovledSet.kt"); } + @Test + @TestMetadata("arrayAssignmentTargetWithTypeParameters.kt") + public void testArrayAssignmentTargetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt"); + } + @Test @TestMetadata("arrayCompoundAssignementTarget.kt") public void testArrayCompoundAssignementTarget() throws Exception { diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt index 6f1f7397853..ccee4d948c5 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction +import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices @@ -20,10 +21,11 @@ import org.jetbrains.kotlin.types.Variance abstract class AbstractAnalysisApiGetSuperTypesTest : AbstractAnalysisApiSingleFileTest(){ override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { val expression = testServices.expressionMarkerProvider.getSelectedElement(ktFile) + expression as? KtExpression ?: error("unexpected expression kind ${expression::class}") val actual = executeOnPooledThreadInReadAction { analyze(expression) { - val expectedType = expression.getExpectedType() ?: error("expect to get type of expression '${expression.text}'") + val expectedType = expression.getKtType() ?: error("expect to get type of expression '${expression.text}'") val directSuperTypes = expectedType.getDirectSuperTypes() val approximatedDirectSuperTypes = expectedType.getDirectSuperTypes(shouldApproximate = true) val allSuperTypes = expectedType.getAllSuperTypes() diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java index 76c10175ce4..c87e42d68e5 100644 --- a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java @@ -41,11 +41,77 @@ public class FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGe ); } + @Test + @TestMetadata("afterExclOperand.kt") + public void testAfterExclOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt"); + } + @Test public void testAllFilesPresentInExpectedExpressionType() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("arrayAccessExpressionGet.kt") + public void testArrayAccessExpressionGet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionGetWithTypeParameters.kt") + public void testArrayAccessExpressionGetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSet.kt") + public void testArrayAccessExpressionSet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt"); + } + + @Test + @TestMetadata("arrayAccessExpressionSetWithTypeParameters.kt") + public void testArrayAccessExpressionSetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithSubject.kt") + public void testConditionInWhenWithSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt"); + } + + @Test + @TestMetadata("conditionInWhenWithoutSubject.kt") + public void testConditionInWhenWithoutSubject() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperand.kt") + public void testElvisExpressionLeftOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionLeftOperandWithoutExplicitType.kt") + public void testElvisExpressionLeftOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperand.kt") + public void testElvisExpressionRightOperand() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt"); + } + + @Test + @TestMetadata("elvisExpressionRightOperandWithoutExplicitType.kt") + public void testElvisExpressionRightOperandWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt"); + } + @Test @TestMetadata("functionExpressionBody.kt") public void testFunctionExpressionBody() throws Exception { @@ -136,6 +202,12 @@ public class FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGe runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionParamQualified.kt"); } + @Test + @TestMetadata("infixFunctionTypeParameter.kt") + public void testInfixFunctionTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt"); + } + @Test @TestMetadata("lambdaWithExplicitTypeFromVariable.kt") public void testLambdaWithExplicitTypeFromVariable() throws Exception { @@ -148,6 +220,42 @@ public class FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGe runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lambdaWithoutReturnNorExplicitType.kt"); } + @Test + @TestMetadata("lastStatementInFunctionBlockBody.kt") + public void testLastStatementInFunctionBlockBody() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt"); + } + + @Test + @TestMetadata("lastStatementInLambda.kt") + public void testLastStatementInLambda() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithTypeMismatch.kt") + public void testLastStatementInLambdaWithTypeMismatch() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt"); + } + + @Test + @TestMetadata("lastStatementInLambdaWithoutExplicitType.kt") + public void testLastStatementInLambdaWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("lastStatementInTry.kt") + public void testLastStatementInTry() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt"); + } + + @Test + @TestMetadata("lastStatementInTryWithoutExplicitType.kt") + public void testLastStatementInTryWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt"); + } + @Test @TestMetadata("propertyDeclaration.kt") public void testPropertyDeclaration() throws Exception { @@ -274,6 +382,42 @@ public class FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGe runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samWithTypeCast.kt"); } + @Test + @TestMetadata("statementInIf.kt") + public void testStatementInIf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt"); + } + + @Test + @TestMetadata("statementInIfBlockExpression.kt") + public void testStatementInIfBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInIfWithoutExplicitType.kt") + public void testStatementInIfWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("statementInWhen.kt") + public void testStatementInWhen() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt"); + } + + @Test + @TestMetadata("statementInWhenBlockExpression.kt") + public void testStatementInWhenBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt"); + } + + @Test + @TestMetadata("statementInWhenWithoutExplicitType.kt") + public void testStatementInWhenWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt"); + } + @Test @TestMetadata("variableAssignment.kt") public void testVariableAssignment() throws Exception { diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java index 9ddb8ca9c77..3b34e72a29a 100644 --- a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java @@ -277,6 +277,12 @@ public class FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerate runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetUnresovledSet.kt"); } + @Test + @TestMetadata("arrayAssignmentTargetWithTypeParameters.kt") + public void testArrayAssignmentTargetWithTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt"); + } + @Test @TestMetadata("arrayCompoundAssignementTarget.kt") public void testArrayCompoundAssignementTarget() throws Exception { diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt new file mode 100644 index 00000000000..b86033d33a5 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.kt @@ -0,0 +1,3 @@ +fun test() { + if (!av) +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.txt new file mode 100644 index 00000000000..53684a9cf4e --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/afterExclOperand.txt @@ -0,0 +1,2 @@ +expression: av +expected type: null diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt new file mode 100644 index 00000000000..3ae278fbbf5 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.kt @@ -0,0 +1,7 @@ +class A { + operator fun get(p1: Int) {} + operator fun set(p1: String, p2: Int, value: Int) {} + + fun d() = this[av] + +} diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGet.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt new file mode 100644 index 00000000000..5cfaffd462b --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.kt @@ -0,0 +1,8 @@ +// IGNORE_FE10 +class A { + operator fun get(key: T) {} +} + +fun test(a: A) { + a[av] +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.txt new file mode 100644 index 00000000000..2f9efbdc830 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionGetWithTypeParameters.txt @@ -0,0 +1,4 @@ +expression: av +expected type: KtTypeParameterType: + annotationsList: [] + type: T diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt new file mode 100644 index 00000000000..f7f0b458397 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.kt @@ -0,0 +1,8 @@ +class A { + operator fun get(p1: Int) {} + operator fun set(p1: String, p2: Int, value: Int) {} + + fun d() { + this[av, 2] = 1 + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.txt new file mode 100644 index 00000000000..906f355865a --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSet.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/String diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt new file mode 100644 index 00000000000..7a39a434047 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.kt @@ -0,0 +1,7 @@ +class A { + operator fun set(key: T, value: T) {} +} + +fun test(a: A) { + a[av] = 1 +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/arrayAccessExpressionSetWithTypeParameters.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt new file mode 100644 index 00000000000..4875e99f266 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.kt @@ -0,0 +1,10 @@ +enum class E { + A + B +} + +fun foo(e: E) { + when(e) { + av -> null + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.txt new file mode 100644 index 00000000000..06b6921e352 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithSubject.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: E diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt new file mode 100644 index 00000000000..dfe4e9d1d8a --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.kt @@ -0,0 +1,5 @@ +fun foo() { + when() { + av -> null + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.txt new file mode 100644 index 00000000000..4499fa16724 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/conditionInWhenWithoutSubject.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Boolean diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt new file mode 100644 index 00000000000..8e37d14d108 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.kt @@ -0,0 +1,3 @@ +fun foo() { + val result: Int = av ?: 1 +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.txt new file mode 100644 index 00000000000..d52265d79a8 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperand.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int? diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt new file mode 100644 index 00000000000..24fbf84c3a0 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.kt @@ -0,0 +1,3 @@ +fun foo() { + av ?: 1 +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.txt new file mode 100644 index 00000000000..d52265d79a8 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionLeftOperandWithoutExplicitType.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int? diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt new file mode 100644 index 00000000000..7e805ef8769 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.kt @@ -0,0 +1,3 @@ +fun foo(i: Int?) { + val result: Int = i ?: av +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperand.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt new file mode 100644 index 00000000000..d55deda82ed --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.kt @@ -0,0 +1,3 @@ +fun foo(i: Int?) { + i ?: av +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/elvisExpressionRightOperandWithoutExplicitType.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.descriptors.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.descriptors.txt deleted file mode 100644 index eb2f1da8ac7..00000000000 --- a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.descriptors.txt +++ /dev/null @@ -1,4 +0,0 @@ -expression: av -expected type: KtTypeErrorType: - annotationsList: [] - type: ERROR_TYPE diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.txt index 327c783de11..53684a9cf4e 100644 --- a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.txt +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.txt @@ -1,4 +1,2 @@ expression: av -expected type: KtClassErrorType: - annotationsList: [] - type: ERROR_TYPE +expected type: null diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.descriptors.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.descriptors.txt new file mode 100644 index 00000000000..bb87eda692c --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.descriptors.txt @@ -0,0 +1,4 @@ +expression: ab +expected type: KtTypeParameterType: + annotationsList: [] + type: T diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.txt index bb87eda692c..8e4ae181a73 100644 --- a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.txt +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.txt @@ -1,4 +1,5 @@ expression: ab -expected type: KtTypeParameterType: +expected type: KtUsualClassType: annotationsList: [] - type: T + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt new file mode 100644 index 00000000000..36f07cd4dd7 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.kt @@ -0,0 +1,5 @@ +fun x() { + 1 toCall av +} + +infix fun T.toCall(y: T) {} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionTypeParameter.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt new file mode 100644 index 00000000000..574672eaada --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.kt @@ -0,0 +1,3 @@ +fun foo(): Int { + av +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.txt new file mode 100644 index 00000000000..f71a5d70da1 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInFunctionBlockBody.txt @@ -0,0 +1,2 @@ +expression: av +expected type: null \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt new file mode 100644 index 00000000000..758351c5029 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.kt @@ -0,0 +1,5 @@ +// WITH_STDLIB +// IGNORE_FE10 +fun foo(list: List) { + val result: List = list.map { av } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.txt new file mode 100644 index 00000000000..906f355865a --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambda.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/String diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt new file mode 100644 index 00000000000..7aa5bc0b18a --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.kt @@ -0,0 +1,4 @@ +// WITH_STDLIB +fun foo(list: List) { + val result: List = list.map { mapOf(av) } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.txt new file mode 100644 index 00000000000..d7913fa1716 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithTypeMismatch.txt @@ -0,0 +1,12 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [ + KtTypeParameterType: + annotationsList: [] + type: K + KtTypeParameterType: + annotationsList: [] + type: V + ] + type: kotlin/Pair diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt new file mode 100644 index 00000000000..9c38057e0c1 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.kt @@ -0,0 +1,4 @@ +// WITH_STDLIB +fun foo(list: List) { + val result = list.map { av } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.txt new file mode 100644 index 00000000000..876e53e774e --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInLambdaWithoutExplicitType.txt @@ -0,0 +1,4 @@ +expression: av +expected type: KtTypeParameterType: + annotationsList: [] + type: R diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt new file mode 100644 index 00000000000..c8cdd7e6c88 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.kt @@ -0,0 +1,5 @@ +fun foo() { + val result: Int = try { + av + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTry.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt new file mode 100644 index 00000000000..3b4927f771e --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.kt @@ -0,0 +1,5 @@ +fun foo() { + try { + av + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.txt new file mode 100644 index 00000000000..f71a5d70da1 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lastStatementInTryWithoutExplicitType.txt @@ -0,0 +1,2 @@ +expression: av +expected type: null \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.descriptors.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.descriptors.txt deleted file mode 100644 index eb2f1da8ac7..00000000000 --- a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.descriptors.txt +++ /dev/null @@ -1,4 +0,0 @@ -expression: av -expected type: KtTypeErrorType: - annotationsList: [] - type: ERROR_TYPE diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.txt index 327c783de11..53684a9cf4e 100644 --- a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.txt +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.txt @@ -1,4 +1,2 @@ expression: av -expected type: KtClassErrorType: - annotationsList: [] - type: ERROR_TYPE +expected type: null diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt new file mode 100644 index 00000000000..c904c24bc44 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.kt @@ -0,0 +1,3 @@ +fun foo() { + val result = if (true) 1 else av +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIf.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt new file mode 100644 index 00000000000..6799323a806 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.kt @@ -0,0 +1,7 @@ +fun foo() { + val result = if (true) { + 1 + } else { + av + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfBlockExpression.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt new file mode 100644 index 00000000000..29b310953e0 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.kt @@ -0,0 +1,3 @@ +fun foo() { + if (true) av else 1 +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInIfWithoutExplicitType.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt new file mode 100644 index 00000000000..16e1ee0e022 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.kt @@ -0,0 +1,11 @@ +enum class E { + A + B +} + +fun foo(e: E) { + val result = when(e) { + E.A -> 1 + E.B -> av + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhen.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt new file mode 100644 index 00000000000..608c9f7fe55 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.kt @@ -0,0 +1,11 @@ +enum class E { + A + B +} + +fun foo(e: E) { + val result = when(e) { + E.A -> { 1 } + E.B -> { av } + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.txt new file mode 100644 index 00000000000..02f4bd1e5bb --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenBlockExpression.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt new file mode 100644 index 00000000000..2a286253b75 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.kt @@ -0,0 +1,13 @@ +enum class E { + A + B + C + D +} + +fun foo(e: E) = when (e) { + E.A -> 1 + E.B -> "" + E.C -> av + E.D -> unresolved +} diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.txt new file mode 100644 index 00000000000..e9676394ca4 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/statementInWhenWithoutExplicitType.txt @@ -0,0 +1,5 @@ +expression: av +expected type: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Any diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt b/analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt new file mode 100644 index 00000000000..9dca84209d7 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.kt @@ -0,0 +1,8 @@ +// IGNORE_FE10 +class A { + operator fun set(key: Int, value: T) {} +} + +fun test(a: A) { + a[1] = "" +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.txt b/analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.txt new file mode 100644 index 00000000000..c68c8c1a906 --- /dev/null +++ b/analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetWithTypeParameters.txt @@ -0,0 +1,2 @@ +expression: a[1] +type: kotlin.String diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.descriptors.txt b/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.descriptors.txt new file mode 100644 index 00000000000..b289a589d08 --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.descriptors.txt @@ -0,0 +1,3 @@ +expression: xy +expected type: (T) -> R +functionClassKind: kotlin.FunctionN diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.txt b/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.txt index b289a589d08..73b47c30de1 100644 --- a/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.txt +++ b/analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.txt @@ -1,3 +1,3 @@ expression: xy -expected type: (T) -> R +expected type: (kotlin.Int) -> R functionClassKind: kotlin.FunctionN