From 7fde5af7f8a460011b25ada9a663e76393de6c30 Mon Sep 17 00:00:00 2001 From: Kirill Rakhman Date: Mon, 21 Aug 2023 17:50:23 +0200 Subject: [PATCH] [FIR] Rename FirExpression.coneType to resolvedType --- .../api/fir/components/KtFirCallResolver.kt | 14 ++--- .../components/KtFirExpressionTypeProvider.kt | 16 +++--- .../api/fir/components/KtFirTypeProvider.kt | 18 ++----- .../evaluate/FirAnnotationValueConverter.kt | 2 +- .../references/FirReferenceResolveHelper.kt | 2 +- .../FirJsDynamicDeclarationChecker.kt | 4 +- .../declaration/FirJsExternalFileChecker.kt | 6 +-- .../FirJsNativeAnnotationCheckers.kt | 4 +- .../expression/FirJsDynamicCallChecker.kt | 5 +- .../expression/FirJsNativeRttiChecker.kt | 5 +- .../checkers/declaration/FirJvmNameChecker.kt | 7 ++- ...JavaGenericVarianceViolationTypeChecker.kt | 2 +- ...otectedInSuperClassCompanionCallChecker.kt | 4 +- ...veForwardDeclarationGetClassCallChecker.kt | 6 +-- ...veForwardDeclarationTypeOperatorChecker.kt | 7 +-- .../analysis/cfa/FirReturnsImpliesAnalyzer.kt | 10 ++-- .../fir/analysis/checkers/FirConstChecks.kt | 20 ++++--- .../fir/analysis/checkers/FirHelpers.kt | 9 ++-- .../FirAmbiguousAnonymousTypeChecker.kt | 8 +-- .../FirDelegateFieldTypeMismatchChecker.kt | 9 ++-- ...esExtensionPropertyTypeParameterChecker.kt | 4 +- .../FirDelegatedPropertyChecker.kt | 12 ++--- .../FirDestructuringDeclarationChecker.kt | 4 +- ...umCompanionInEnumConstructorCallChecker.kt | 8 +-- .../FirInlineDeclarationChecker.kt | 2 +- .../FirAssignmentOperatorCallChecker.kt | 4 +- .../FirAssignmentTypeMismatchChecker.kt | 6 +-- .../expression/FirCastOperatorsChecker.kt | 5 +- .../expression/FirClassLiteralChecker.kt | 9 ++-- .../FirEqualityCompatibilityChecker.kt | 8 +-- .../expression/FirExhaustiveWhenChecker.kt | 4 +- .../FirFunctionReturnTypeMismatchChecker.kt | 7 ++- .../expression/FirNotNullAssertionChecker.kt | 12 +++-- .../expression/FirOptInUsageAccessChecker.kt | 9 ++-- ...irReassignmentAndInvisibleSetterChecker.kt | 5 +- .../expression/FirRecursiveProblemChecker.kt | 2 +- .../expression/FirSpreadOfNullableChecker.kt | 8 +-- .../FirStandaloneQualifierChecker.kt | 9 ++-- .../expression/FirSuspendCallChecker.kt | 8 +-- .../FirThrowExpressionTypeChecker.kt | 11 ++-- .../FirUnnecessarySafeCallChecker.kt | 14 ++--- .../FirUnsupportedArrayLiteralChecker.kt | 4 +- .../FirUpperBoundViolatedExpressionChecker.kt | 8 +-- .../expression/FirUselessElvisChecker.kt | 10 ++-- .../FirUselessTypeOperationCallChecker.kt | 2 +- .../ArrayEqualityCanBeReplacedWithEquals.kt | 12 ++--- ...BeReplacedWithOperatorAssignmentChecker.kt | 4 +- .../RedundantCallOfConversionMethod.kt | 18 +++---- ...ntSingleExpressionStringTemplateChecker.kt | 10 ++-- .../extended/UselessCallOnNotNullChecker.kt | 6 +-- .../jetbrains/kotlin/fir/dump/HtmlFirDump.kt | 4 +- .../constant/FirToConstantValueTransformer.kt | 3 +- .../kotlin/fir/backend/ConversionUtils.kt | 11 ++-- .../fir/backend/Fir2IrDeclarationStorage.kt | 10 ++-- .../fir/backend/Fir2IrImplicitCastInserter.kt | 8 +-- .../kotlin/fir/backend/Fir2IrVisitor.kt | 54 +++++++++---------- .../kotlin/fir/backend/PrimitiveComparison.kt | 6 +-- .../backend/generators/AdapterGenerator.kt | 6 +-- .../generators/CallAndReferenceGenerator.kt | 18 +++---- .../generators/ClassMemberGenerator.kt | 6 ++- .../generators/DelegatedMemberGenerator.kt | 3 +- .../generators/OperatorExpressionGenerator.kt | 6 +-- .../kotlin/fir/lazy/Fir2IrLazyProperty.kt | 8 +-- .../java/deserialization/AnnotationsLoader.kt | 2 +- .../src/org/jetbrains/kotlin/fir/CopyUtils.kt | 2 +- .../kotlin/fir/FirVisibilityChecker.kt | 11 ++-- .../fir/declarations/FirAnnotationUtils.kt | 2 +- .../kotlin/fir/resolve/ScopeUtils.kt | 2 +- .../jetbrains/kotlin/fir/FirCallResolver.kt | 6 +-- .../FirDoubleColonExpressionResolver.kt | 2 +- .../kotlin/fir/resolve/ResolveUtils.kt | 2 +- .../kotlin/fir/resolve/calls/Arguments.kt | 4 +- .../fir/resolve/calls/CandidateFactory.kt | 3 +- .../fir/resolve/calls/ResolutionStages.kt | 22 +++++--- .../fir/resolve/calls/VisibilityUtils.kt | 6 +-- .../fir/resolve/calls/tower/TowerLevels.kt | 4 +- .../fir/resolve/dfa/FirDataFlowAnalyzer.kt | 26 ++++----- .../inference/FirBuilderInferenceSession.kt | 4 +- .../FirDelegatedPropertyInferenceSession.kt | 9 ++-- ...rCallCompletionResultsWriterTransformer.kt | 12 ++--- .../FirWhenExhaustivenessTransformer.kt | 2 +- ...ControlFlowStatementsResolveTransformer.kt | 4 +- .../FirDeclarationsResolveTransformer.kt | 4 +- .../FirExpressionsResolveTransformer.kt | 10 ++-- .../contracts/ConeEffectExtractor.kt | 4 +- .../mpp/FirExpectActualMatchingContextImpl.kt | 2 +- .../kotlin/fir/resolve/dfa/cfg/CFGNode.kt | 4 +- .../kotlin/fir/types/FirTypeUtils.kt | 2 +- .../compiler/visualizer/FirVisualizer.kt | 18 +++---- .../checkers/SignedNumberCallChecker.kt | 7 +-- .../FirSerializationPluginClassChecker.kt | 4 +- 91 files changed, 364 insertions(+), 342 deletions(-) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt index 9e3b3fa6728..4ae9a909bf5 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt @@ -421,7 +421,7 @@ internal class KtFirCallResolver( val extensionReceiverValue: KtReceiverValue? if (explicitReceiverKind == ExplicitReceiverKind.DISPATCH_RECEIVER) { dispatchReceiverValue = - KtExplicitReceiverValue(explicitReceiverPsi, dispatchReceiver.coneType.asKtType(), false, token) + KtExplicitReceiverValue(explicitReceiverPsi, dispatchReceiver.resolvedType.asKtType(), false, token) if (firstArgIsExtensionReceiver) { extensionReceiverValue = (fir as FirFunctionCall).arguments.firstOrNull()?.toKtReceiverValue() } else { @@ -430,7 +430,7 @@ internal class KtFirCallResolver( } else { dispatchReceiverValue = dispatchReceiver.toKtReceiverValue() extensionReceiverValue = - KtExplicitReceiverValue(explicitReceiverPsi, extensionReceiver.coneType.asKtType(), false, token) + KtExplicitReceiverValue(explicitReceiverPsi, extensionReceiver.resolvedType.asKtType(), false, token) } return KtPartiallyAppliedSymbol( with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) }, @@ -777,12 +777,12 @@ internal class KtFirCallResolver( (calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirNamedFunctionSymbol ?: return null val substitutor = createConeSubstitutorFromTypeArguments() ?: return null val dispatchReceiverValue = if (explicitReceiverPsiSupplement != null && explicitReceiver == dispatchReceiver) { - explicitReceiverPsiSupplement.toExplicitReceiverValue(dispatchReceiver.coneType.asKtType()) + explicitReceiverPsiSupplement.toExplicitReceiverValue(dispatchReceiver.resolvedType.asKtType()) } else { dispatchReceiver.toKtReceiverValue() } val extensionReceiverValue = if (explicitReceiverPsiSupplement != null && explicitReceiver == extensionReceiver) { - explicitReceiverPsiSupplement.toExplicitReceiverValue(extensionReceiver.coneType.asKtType()) + explicitReceiverPsiSupplement.toExplicitReceiverValue(extensionReceiver.resolvedType.asKtType()) } else { extensionReceiver.toKtReceiverValue() } @@ -811,12 +811,12 @@ internal class KtFirCallResolver( ?: return null else -> return null } - KtImplicitReceiverValue(implicitPartiallyAppliedSymbol, coneType.asKtType()) + KtImplicitReceiverValue(implicitPartiallyAppliedSymbol, resolvedType.asKtType()) } else -> { val psi = psi if (psi !is KtExpression) return null - psi.toExplicitReceiverValue(coneType.asKtType()) + psi.toExplicitReceiverValue(resolvedType.asKtType()) } } } @@ -1169,7 +1169,7 @@ internal class KtFirCallResolver( val equalsSymbolInAny = equalsSymbolInAny val leftOperand = arguments.firstOrNull() ?: return null val session = analysisSession.useSiteSession - val leftOperandType = leftOperand.coneType + val leftOperandType = leftOperand.resolvedType val classSymbol = leftOperandType.fullyExpandedType(session).toSymbol(session) as? FirClassSymbol<*> val equalsSymbol = classSymbol?.getEqualsSymbol(equalsSymbolInAny) ?: equalsSymbolInAny 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 50cec24e56d..c23e804daf1 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 @@ -31,8 +31,8 @@ import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.utils.addToStdlib.applyIf import org.jetbrains.kotlin.psi.psiUtil.getOutermostParenthesizerOrThis +import org.jetbrains.kotlin.utils.addToStdlib.applyIf import org.jetbrains.kotlin.utils.exceptions.rethrowExceptionWithDetails import org.jetbrains.kotlin.utils.exceptions.withPsiEntry @@ -67,7 +67,7 @@ internal class KtFirExpressionTypeProvider( } private fun getKtExpressionType(expression: KtExpression, fir: FirElement): KtType? = when (fir) { - is FirFunctionCall -> getReturnTypeForArrayStyleAssignmentTarget(expression, fir) ?: fir.coneType.asKtType() + is FirFunctionCall -> getReturnTypeForArrayStyleAssignmentTarget(expression, fir) ?: fir.resolvedType.asKtType() is FirPropertyAccessExpression -> { // For unresolved `super`, we manually create an intersection type so that IDE features like completion can work correctly. val containingClass = (fir.dispatchReceiver as? FirThisReceiverExpression)?.calleeReference?.boundSymbol as? FirClassSymbol<*> @@ -80,19 +80,19 @@ internal class KtFirExpressionTypeProvider( else -> ConeIntersectionType(superTypes).asKtType() } } else { - fir.coneType.asKtType() + fir.resolvedType.asKtType() } } is FirVariableAssignment -> { if (fir.lValue.source?.psi == expression) { - fir.lValue.coneType.asKtType() + fir.lValue.resolvedType.asKtType() } else if (expression is KtUnaryExpression && expression.operationToken in KtTokens.INCREMENT_AND_DECREMENT) { - fir.rValue.coneType.asKtType() + fir.rValue.resolvedType.asKtType() } else { analysisSession.builtinTypes.UNIT } } - is FirExpression -> fir.coneType.asKtType() + is FirExpression -> fir.resolvedType.asKtType() is FirNamedReference -> fir.getCorrespondingTypeIfPossible()?.asKtType() is FirStatement -> with(analysisSession) { builtinTypes.UNIT } is FirTypeRef, is FirImport, is FirPackageDirective, is FirLabel, is FirTypeParameterRef -> null @@ -123,7 +123,7 @@ internal class KtFirExpressionTypeProvider( * of the whole expression instead, and that is not what he wants. */ private fun FirNamedReference.getCorrespondingTypeIfPossible(): ConeKotlinType? = - findOuterPropertyAccessExpression()?.coneType + findOuterPropertyAccessExpression()?.resolvedType /** * Finds an outer expression for [this] named reference in cases when it is a part of a property access. @@ -425,7 +425,7 @@ internal class KtFirExpressionTypeProvider( private fun getDefiniteNullability(expression: KtExpression): DefiniteNullability { fun FirExpression.isNotNullable() = with(analysisSession.useSiteSession.typeContext) { - !coneType.isNullableType() + !resolvedType.isNullableType() } when (val fir = expression.getOrBuildFir(analysisSession.firResolveSession)) { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt index 0aebd45de5e..2391e4b6a39 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt @@ -36,23 +36,13 @@ import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.renderer.FirRenderer import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.name.StandardClassIds -import org.jetbrains.kotlin.psi.KtAnnotationEntry -import org.jetbrains.kotlin.psi.KtCallableDeclaration -import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtConstructorCalleeExpression -import org.jetbrains.kotlin.psi.KtDoubleColonExpression -import org.jetbrains.kotlin.psi.KtElement -import org.jetbrains.kotlin.psi.KtNamedDeclaration -import org.jetbrains.kotlin.psi.KtNamedFunction -import org.jetbrains.kotlin.psi.KtParameter -import org.jetbrains.kotlin.psi.KtProperty -import org.jetbrains.kotlin.psi.KtTypeReference +import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.types.TypeApproximatorConfiguration import org.jetbrains.kotlin.types.model.CaptureStatus import org.jetbrains.kotlin.util.bfs @@ -172,9 +162,9 @@ internal class KtFirTypeProvider( override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? { return when (val fir = expression.getOrBuildFir(firResolveSession)) { is FirGetClassCall -> - fir.coneType.getReceiverOfReflectionType()?.asKtType() + fir.resolvedType.getReceiverOfReflectionType()?.asKtType() is FirCallableReferenceAccess -> - fir.coneType.getReceiverOfReflectionType()?.asKtType() + fir.resolvedType.getReceiverOfReflectionType()?.asKtType() else -> throwUnexpectedFirElementError(fir, expression) } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt index 1d23bd284e2..1e398ea0fb9 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt @@ -179,7 +179,7 @@ internal object FirAnnotationValueConverter { val qualifierParts = mutableListOf() fun process(expression: FirExpression) { - val errorType = expression.coneType as? ConeErrorType + val errorType = expression.resolvedType as? ConeErrorType val unresolvedName = when (val diagnostic = errorType?.diagnostic) { is ConeUnresolvedTypeQualifierError -> diagnostic.qualifier is ConeUnresolvedNameError -> diagnostic.qualifier diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt index 868c013da8a..15798a70424 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt @@ -261,7 +261,7 @@ internal object FirReferenceResolveHelper { symbolBuilder: KtSymbolByFirBuilder ): Collection { val lhs = expression.arguments.firstOrNull() ?: return emptyList() - val scope = lhs.coneType.scope( + val scope = lhs.resolvedType.scope( session, analysisSession.getScopeSessionFor(analysisSession.useSiteSession), FakeOverrideTypeCalculator.DoNothing, diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsDynamicDeclarationChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsDynamicDeclarationChecker.kt index 7828a183c55..0fc6f84ef75 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsDynamicDeclarationChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsDynamicDeclarationChecker.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.delegateFieldsMap import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.types.ConeDynamicType -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType object FirJsDynamicDeclarationChecker : FirClassChecker() { override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { @@ -27,7 +27,7 @@ object FirJsDynamicDeclarationChecker : FirClassChecker() { // and it's a shape it couldn't have been accessed directly val initializer = delegate.fir.initializer ?: continue - if (initializer.coneType is ConeDynamicType) { + if (initializer.resolvedType is ConeDynamicType) { reporter.reportOn(initializer.source, FirJsErrors.DELEGATION_BY_DYNAMIC, context) } } diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExternalFileChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExternalFileChecker.kt index 2451c1b0686..43400285312 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExternalFileChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExternalFileChecker.kt @@ -10,12 +10,12 @@ import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.closestNonLocalWith import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker -import org.jetbrains.kotlin.fir.analysis.js.checkers.isNativeObject import org.jetbrains.kotlin.fir.analysis.checkers.isTopLevel import org.jetbrains.kotlin.fir.analysis.diagnostics.js.FirJsErrors +import org.jetbrains.kotlin.fir.analysis.js.checkers.isNativeObject import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.name.JsStandardClassIds object FirJsExternalFileChecker : FirBasicDeclarationChecker() { @@ -34,7 +34,7 @@ object FirJsExternalFileChecker : FirBasicDeclarationChecker() { reporter.reportOn( declaration.source, FirJsErrors.NON_EXTERNAL_DECLARATION_IN_INAPPROPRIATE_FILE, - targetAnnotations.coneType, + targetAnnotations.resolvedType, context ) } diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsNativeAnnotationCheckers.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsNativeAnnotationCheckers.kt index 220d63d8745..9ec6c478f05 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsNativeAnnotationCheckers.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsNativeAnnotationCheckers.kt @@ -10,9 +10,9 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirSimpleFunctionChecker -import org.jetbrains.kotlin.fir.analysis.js.checkers.isNativeObject import org.jetbrains.kotlin.fir.analysis.checkers.isTopLevel import org.jetbrains.kotlin.fir.analysis.diagnostics.js.FirJsErrors +import org.jetbrains.kotlin.fir.analysis.js.checkers.isNativeObject import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId @@ -36,7 +36,7 @@ internal abstract class FirJsAbstractNativeAnnotationChecker(private val require reporter.reportOn( declaration.source, FirJsErrors.NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN, - annotation.coneType, + annotation.resolvedType, context ) } diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt index eab7e917a47..7e23b3a980d 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirBasicExpressionChecker import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirQualifiedAccessExpressionChecker import org.jetbrains.kotlin.fir.analysis.diagnostics.js.FirJsErrors import org.jetbrains.kotlin.fir.analysis.js.checkers.sanitizeName @@ -21,7 +20,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.resolved import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.types.ConeDynamicType -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.util.OperatorNameConventions private val nameToOperator = mapOf( @@ -90,7 +89,7 @@ object FirJsDynamicCallChecker : FirQualifiedAccessExpressionChecker() { private fun checkSpreadOperator(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { forAllSpreadArgumentsOf(expression) { - if (it.coneType is ConeDynamicType) { + if (it.resolvedType is ConeDynamicType) { reporter.reportOn(it.source, FirJsErrors.WRONG_OPERATION_WITH_DYNAMIC, "spread operator", context) } } diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsNativeRttiChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsNativeRttiChecker.kt index 034994022be..a5d08d5a1c9 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsNativeRttiChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsNativeRttiChecker.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.js.FirJsErrors import org.jetbrains.kotlin.fir.analysis.js.checkers.isNativeInterface import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol object FirJsNativeRttiChecker : FirBasicExpressionChecker() { @@ -26,7 +27,7 @@ object FirJsNativeRttiChecker : FirBasicExpressionChecker() { } private fun checkGetClassCall(expression: FirGetClassCall, context: CheckerContext, reporter: DiagnosticReporter) { - val declarationToCheck = expression.argument.coneType.toRegularClassSymbol(context.session) ?: return + val declarationToCheck = expression.argument.resolvedType.toRegularClassSymbol(context.session) ?: return if (expression.arguments.firstOrNull() !is FirResolvedQualifier) { return @@ -49,7 +50,7 @@ object FirJsNativeRttiChecker : FirBasicExpressionChecker() { FirOperation.AS, FirOperation.SAFE_AS -> reporter.reportOn( expression.source, FirJsErrors.UNCHECKED_CAST_TO_EXTERNAL_INTERFACE, - expression.argument.coneType, + expression.argument.resolvedType, targetTypeRef.coneType, context, ) diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt index 5d907da7843..58a04a1a3d7 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt @@ -13,12 +13,15 @@ import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclaratio import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.declarations.utils.* +import org.jetbrains.kotlin.fir.declarations.utils.isInline +import org.jetbrains.kotlin.fir.declarations.utils.isOverridable +import org.jetbrains.kotlin.fir.declarations.utils.isOverride import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.resolve.getContainingClass import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds @@ -28,7 +31,7 @@ object FirJvmNameChecker : FirBasicDeclarationChecker() { val jvmName = declaration.findJvmNameAnnotation() ?: return val name = jvmName.findArgumentByName(StandardNames.NAME) ?: return - if (name.coneType != context.session.builtinTypes.stringType.type) { + if (name.resolvedType != context.session.builtinTypes.stringType.type) { return } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt index 398e09d76cf..21e248a4913 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt @@ -70,7 +70,7 @@ object FirJavaGenericVarianceViolationTypeChecker : FirFunctionCallChecker() { // Anything is acceptable for raw types if (expectedType is ConeRawType) continue - val argType = arg.coneType + val argType = arg.resolvedType val lowerBound = expectedType.lowerBound val upperBound = expectedType.upperBound diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt index ed24b1afa7a..29b278067e8 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol import org.jetbrains.kotlin.fir.types.typeContext import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_CLASS_ID @@ -38,7 +38,7 @@ object FirJvmProtectedInSuperClassCompanionCallChecker : FirBasicExpressionCheck } ?: return if (dispatchReceiver is FirNoReceiverExpression) return - val dispatchClassSymbol = dispatchReceiver.coneType.toRegularClassSymbol(context.session) ?: return + val dispatchClassSymbol = dispatchReceiver.resolvedType.toRegularClassSymbol(context.session) ?: return val calleeReference = expression.calleeReference val resolvedSymbol = calleeReference?.toResolvedCallableSymbol() ?: return diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationGetClassCallChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationGetClassCallChecker.kt index 5ae08ebf6c9..832b2481ba2 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationGetClassCallChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationGetClassCallChecker.kt @@ -12,13 +12,13 @@ import org.jetbrains.kotlin.fir.analysis.native.checkers.forwardDeclarationKindO import org.jetbrains.kotlin.fir.expressions.FirGetClassCall import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.arguments -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol object FirNativeForwardDeclarationGetClassCallChecker : FirGetClassCallChecker() { override fun check(expression: FirGetClassCall, context: CheckerContext, reporter: DiagnosticReporter) { - val declarationToCheck = expression.argument.coneType.toRegularClassSymbol(context.session) ?: return + val declarationToCheck = expression.argument.resolvedType.toRegularClassSymbol(context.session) ?: return if (expression.arguments.firstOrNull() !is FirResolvedQualifier) { return @@ -28,7 +28,7 @@ object FirNativeForwardDeclarationGetClassCallChecker : FirGetClassCallChecker() reporter.reportOn( expression.source, FirNativeErrors.FORWARD_DECLARATION_AS_CLASS_LITERAL, - expression.argument.coneType, + expression.argument.resolvedType, context, ) } diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationTypeOperatorChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationTypeOperatorChecker.kt index 10c944c7b44..4fed5bb6be4 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationTypeOperatorChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeForwardDeclarationTypeOperatorChecker.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.argument import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol object FirNativeForwardDeclarationTypeOperatorChecker : FirTypeOperatorCallChecker() { @@ -27,7 +28,7 @@ object FirNativeForwardDeclarationTypeOperatorChecker : FirTypeOperatorCallCheck when (expression.operation) { FirOperation.AS, FirOperation.SAFE_AS -> { - val sourceClass = expression.argument.coneType.toRegularClassSymbol(context.session) + val sourceClass = expression.argument.resolvedType.toRegularClassSymbol(context.session) // It can make sense to avoid warning if sourceClass is subclass of class with such property, // but for the sake of simplicity, we don't do it now. if (sourceClass != null && sourceClass.classKind == fwdKind.classKind && sourceClass.name == declarationToCheck.name) { @@ -44,8 +45,8 @@ object FirNativeForwardDeclarationTypeOperatorChecker : FirTypeOperatorCallCheck reporter.reportOn( expression.source, FirNativeErrors.UNCHECKED_CAST_TO_FORWARD_DECLARATION, - expression.argument.coneType, - expression.argument.coneType, + expression.argument.resolvedType, + expression.argument.resolvedType, context, ) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt index 4485293e8bc..e9de597b4f3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt @@ -12,12 +12,16 @@ import org.jetbrains.kotlin.fir.analysis.cfa.util.previousCfgNodes import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.fir.contracts.description.* +import org.jetbrains.kotlin.fir.contracts.description.ConeConditionalEffectDeclaration +import org.jetbrains.kotlin.fir.contracts.description.ConeReturnsEffectDeclaration import org.jetbrains.kotlin.fir.contracts.effects import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.expressions.FirConstExpression +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirReturnExpression +import org.jetbrains.kotlin.fir.expressions.FirWhenExpression import org.jetbrains.kotlin.fir.resolve.dfa.* import org.jetbrains.kotlin.fir.resolve.dfa.cfg.BlockExitNode import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode @@ -78,7 +82,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() { val isReturn = node is JumpNode && node.fir is FirReturnExpression val resultExpression = if (isReturn) (node.fir as FirReturnExpression).result else node.fir - val expressionType = (resultExpression as? FirExpression)?.coneType + val expressionType = (resultExpression as? FirExpression)?.resolvedType if (expressionType == builtinTypes.nothingType.type) return false if (isReturn && resultExpression is FirWhenExpression) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt index db187d27b33..3d352213d06 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt @@ -85,7 +85,7 @@ internal fun checkConstantArguments( } } expression is FirGetClassCall -> { - var coneType = (expression as? FirCall)?.argument?.coneType + var coneType = (expression as? FirCall)?.argument?.resolvedType if (coneType is ConeErrorType) return ConstantArgumentKind.NOT_CONST @@ -109,7 +109,7 @@ internal fun checkConstantArguments( } expressionSymbol is FirConstructorSymbol -> { if (expression is FirCallableReferenceAccess) return null - if (expression.coneType.isUnsignedType) { + if (expression.resolvedType.isUnsignedType) { (expression as FirFunctionCall).arguments.forEach { argumentExpression -> checkConstantArguments(argumentExpression, session)?.let { return it } } @@ -122,7 +122,7 @@ internal fun checkConstantArguments( if (calleeReference is FirErrorNamedReference) { return null } - if (expression.coneType.classId == StandardClassIds.KClass) { + if (expression.resolvedType.classId == StandardClassIds.KClass) { return ConstantArgumentKind.NOT_KCLASS_LITERAL } @@ -140,7 +140,7 @@ internal fun checkConstantArguments( for (exp in expression.arguments.plus(expression.dispatchReceiver).plus(expression.extensionReceiver)) { if (exp is FirNoReceiverExpression) continue - val expClassId = exp.coneType.lowerBoundIfFlexible().classId + val expClassId = exp.resolvedType.lowerBoundIfFlexible().classId // TODO, KT-59823: add annotation for allowed constant types if (expClassId !in StandardClassIds.constantAllowedTypes) { return ConstantArgumentKind.NOT_CONST @@ -152,8 +152,11 @@ internal fun checkConstantArguments( return null } expression is FirQualifiedAccessExpression -> { - val expressionType = expression.coneType - if (expressionType.isReflectFunctionType(session) || expressionType.isKProperty(session) || expressionType.isKMutableProperty(session)) { + val expressionType = expression.resolvedType + if (expressionType.isReflectFunctionType(session) || expressionType.isKProperty(session) || expressionType.isKMutableProperty( + session + ) + ) { return checkConstantArguments(expression.dispatchReceiver, session) } @@ -163,7 +166,8 @@ internal fun checkConstantArguments( val property = propertySymbol.fir when { property.unwrapFakeOverrides().symbol.canBeEvaluated() || property.isCompileTimeBuiltinProperty() -> { - val receiver = listOf(expression.dispatchReceiver, expression.extensionReceiver).single { it != FirNoReceiverExpression } + val receiver = + listOf(expression.dispatchReceiver, expression.extensionReceiver).single { it != FirNoReceiverExpression } return checkConstantArguments(receiver, session) } propertySymbol.isLocal || propertySymbol.callableId.className?.isRoot == false -> return ConstantArgumentKind.NOT_CONST @@ -195,7 +199,7 @@ private fun FirExpression.isForbiddenComplexConstant(session: FirSession): Boole private val FirExpression.isComplexBooleanConstant get(): Boolean = when { - !coneType.isBoolean -> false + !resolvedType.isBoolean -> false this is FirConstExpression<*> -> false usesVariableAsConstant -> false else -> true diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt index df09c2233c3..9af4e3b828d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt @@ -38,7 +38,10 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.name.* +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.psi.KtParameter import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET import org.jetbrains.kotlin.resolve.AnnotationTargetList @@ -452,7 +455,7 @@ fun checkTypeMismatch( isInitializer: Boolean ) { var lValueType = lValueOriginalType - var rValueType = rValue.coneType + var rValueType = rValue.resolvedType if (source.kind is KtFakeSourceElementKind.DesugaredIncrementOrDecrement) { if (!lValueType.isNullable && rValueType.isNullable) { val tempType = rValueType @@ -512,7 +515,7 @@ fun checkTypeMismatch( } internal fun checkCondition(condition: FirExpression, context: CheckerContext, reporter: DiagnosticReporter) { - val coneType = condition.coneType.lowerBoundIfFlexible() + val coneType = condition.resolvedType.lowerBoundIfFlexible() if (coneType !is ConeErrorType && !coneType.isSubtypeOf(context.session.typeContext, context.session.builtinTypes.booleanType.type)) { reporter.reportOn( condition.source, diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt index 32b72f7c81e..a5b9af93f11 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt @@ -6,10 +6,10 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.expressions.FirBlock @@ -41,7 +41,7 @@ object FirAmbiguousAnonymousTypeChecker : FirBasicDeclarationChecker() { * 3. `val x get() = ...` */ val type = when (declaration) { - is FirProperty -> declaration.initializer?.coneType ?: declaration.getter?.body?.singleExpressionType + is FirProperty -> declaration.initializer?.resolvedType ?: declaration.getter?.body?.singleExpressionType is FirFunction -> declaration.body?.singleExpressionType else -> error("Should not be there") } ?: return @@ -76,5 +76,5 @@ object FirAmbiguousAnonymousTypeChecker : FirBasicDeclarationChecker() { } private val FirBlock.singleExpressionType - get() = ((this as? FirSingleExpressionBlock)?.statement as? FirReturnExpression)?.result?.coneType + get() = ((this as? FirSingleExpressionBlock)?.statement as? FirReturnExpression)?.result?.resolvedType } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt index 17dcf5b48ab..25844f5e681 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt @@ -5,10 +5,10 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.delegateFieldsMap import org.jetbrains.kotlin.fir.expressions.FirCall @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.references.isError import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isSubtypeOf +import org.jetbrains.kotlin.fir.types.resolvedType object FirDelegateFieldTypeMismatchChecker : FirRegularClassChecker() { @SymbolInternals @@ -29,13 +30,13 @@ object FirDelegateFieldTypeMismatchChecker : FirRegularClassChecker() { if ( !isReportedByErrorNodeDiagnosticCollector && - !initializer.coneType.isSubtypeOf(supertype.coneType, context.session, true) + !initializer.resolvedType.isSubtypeOf(supertype.coneType, context.session, true) ) { reporter.reportOn( initializer.source, FirErrors.TYPE_MISMATCH, field.returnTypeRef.coneType, - initializer.coneType, + initializer.resolvedType, false, context, ) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt index 3739c25ec59..bb3ac84fe72 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt @@ -24,7 +24,7 @@ object FirDelegateUsesExtensionPropertyTypeParameterChecker : FirPropertyChecker val delegate = declaration.delegate as? FirFunctionCall ?: return val parameters = declaration.typeParameters.mapTo(hashSetOf()) { it.symbol } - val usedTypeParameterSymbol = delegate.coneType.findUsedTypeParameterSymbol(parameters, delegate, context, reporter) + val usedTypeParameterSymbol = delegate.resolvedType.findUsedTypeParameterSymbol(parameters, delegate, context, reporter) ?: return reporter.reportOn(declaration.source, FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER, usedTypeParameterSymbol, context) @@ -37,7 +37,7 @@ object FirDelegateUsesExtensionPropertyTypeParameterChecker : FirPropertyChecker reporter: DiagnosticReporter, ): FirTypeParameterSymbol? { val expandedDelegateClassLikeType = - delegate.coneType.lowerBoundIfFlexible().fullyExpandedType(context.session) + delegate.resolvedType.lowerBoundIfFlexible().fullyExpandedType(context.session) .unwrapDefinitelyNotNull() as? ConeClassLikeType ?: return null val delegateClassSymbol = expandedDelegateClassLikeType.lookupTag.toSymbol(context.session) as? FirRegularClassSymbol ?: return null val delegateClassScope by lazy { delegateClassSymbol.unsubstitutedScope(context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegatedPropertyChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegatedPropertyChecker.kt index 6ec5c4631cf..3760ac7291f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegatedPropertyChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegatedPropertyChecker.kt @@ -6,19 +6,17 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.KtFakeSourceElementKind +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall import org.jetbrains.kotlin.fir.expressions.arguments -import org.jetbrains.kotlin.fir.references.FirErrorNamedReference -import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference import org.jetbrains.kotlin.fir.references.isError import org.jetbrains.kotlin.fir.resolve.diagnostics.* import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol @@ -30,7 +28,7 @@ import org.jetbrains.kotlin.types.AbstractTypeChecker object FirDelegatedPropertyChecker : FirPropertyChecker() { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { val delegate = declaration.delegate ?: return - val delegateType = delegate.coneType + val delegateType = delegate.resolvedType val source = delegate.source; if (delegateType is ConeErrorType) { @@ -66,7 +64,7 @@ object FirDelegatedPropertyChecker : FirPropertyChecker() { val diagnostic = if (reference.isError()) reference.diagnostic else return false if (reference.source?.kind != KtFakeSourceElementKind.DelegatedPropertyAccessor) return false val expectedFunctionSignature = - (if (isGet) "getValue" else "setValue") + "(${functionCall.arguments.joinToString(", ") { it.coneType.renderReadable() }})" + (if (isGet) "getValue" else "setValue") + "(${functionCall.arguments.joinToString(", ") { it.resolvedType.renderReadable() }})" val delegateDescription = if (isGet) "delegate" else "delegate for var (read-write property)" fun reportInapplicableDiagnostics(candidates: Collection>) { @@ -124,7 +122,7 @@ object FirDelegatedPropertyChecker : FirPropertyChecker() { } private fun checkReturnType(functionCall: FirFunctionCall) { - val returnType = functionCall.coneType + val returnType = functionCall.resolvedType val propertyType = declaration.returnTypeRef.coneType if (!AbstractTypeChecker.isSubtypeOf(context.session.typeContext, returnType, propertyType)) { reporter.reportOn( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt index 26c62951501..c2f0fb72d2e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt @@ -68,7 +68,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() { val originalDestructuringDeclarationType = when (originalDestructuringDeclarationOrInitializer) { is FirVariable -> originalDestructuringDeclarationOrInitializer.returnTypeRef.coneType - is FirExpression -> originalDestructuringDeclarationOrInitializer.coneType + is FirExpression -> originalDestructuringDeclarationOrInitializer.resolvedType else -> null } ?: return @@ -154,7 +154,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() { } } is ConeConstraintSystemHasContradiction -> { - val componentType = componentCall.coneType + val componentType = componentCall.resolvedType if (componentType is ConeErrorType) { // There will be other errors on this error type. return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt index d720bd8fa2b..3df317141a1 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt @@ -12,7 +12,9 @@ import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier @@ -25,7 +27,7 @@ import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FunctionCallNode import org.jetbrains.kotlin.fir.resolve.dfa.cfg.QualifiedAccessNode import org.jetbrains.kotlin.fir.resolve.dfa.controlFlowGraph import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull @@ -92,7 +94,7 @@ object FirEnumCompanionInEnumConstructorCallChecker : FirClassChecker() { private fun FirExpression.getClassSymbol(session: FirSession): FirRegularClassSymbol? { return when (this) { is FirResolvedQualifier -> { - this.coneType.toRegularClassSymbol(session) + this.resolvedType.toRegularClassSymbol(session) } else -> (this.toReference() as? FirThisReference)?.boundSymbol } as? FirRegularClassSymbol diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt index 21a86922844..b7721de011b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt @@ -286,7 +286,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { } as? FirQualifiedAccessExpression ?: return if (receiver.calleeReference is FirSuperReference) { - val dispatchReceiverType = receiver.dispatchReceiver.coneType + val dispatchReceiverType = receiver.dispatchReceiver.resolvedType val classSymbol = dispatchReceiverType.toSymbol(session) ?: return if (!classSymbol.isDefinedInInlineFunction()) { reporter.reportOn( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentOperatorCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentOperatorCallChecker.kt index 3731ee4bd20..9f114e90307 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentOperatorCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentOperatorCallChecker.kt @@ -13,8 +13,8 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin import org.jetbrains.kotlin.fir.expressions.FirOperationNameConventions import org.jetbrains.kotlin.fir.references.toResolvedNamedFunctionSymbol -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isUnit +import org.jetbrains.kotlin.fir.types.resolvedType object FirAssignmentOperatorCallChecker : FirFunctionCallChecker() { override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { @@ -25,7 +25,7 @@ object FirAssignmentOperatorCallChecker : FirFunctionCallChecker() { ) { return } - if (!expression.coneType.isUnit) { + if (!expression.resolvedType.isUnit) { reporter.reportOn( expression.source, FirErrors.ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT, diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentTypeMismatchChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentTypeMismatchChecker.kt index 9f7a94d9bb4..c6e0bba8300 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentTypeMismatchChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAssignmentTypeMismatchChecker.kt @@ -5,16 +5,16 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.checkers.checkTypeMismatch import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType object FirAssignmentTypeMismatchChecker : FirVariableAssignmentChecker() { override fun check(expression: FirVariableAssignment, context: CheckerContext, reporter: DiagnosticReporter) { val source = expression.rValue.source ?: return - val coneType = expression.lValue.coneType + val coneType = expression.lValue.resolvedType checkTypeMismatch( coneType, expression, diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCastOperatorsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCastOperatorsChecker.kt index 2827ddf84f6..b029061c954 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCastOperatorsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCastOperatorsChecker.kt @@ -9,9 +9,9 @@ import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.CastingType +import org.jetbrains.kotlin.fir.analysis.checkers.checkCasting import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.isCastErased -import org.jetbrains.kotlin.fir.analysis.checkers.checkCasting import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.FirOperation import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall @@ -19,12 +19,13 @@ import org.jetbrains.kotlin.fir.expressions.unwrapSmartcastExpression import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.types.ConeDynamicType import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType object FirCastOperatorsChecker : FirTypeOperatorCallChecker() { override fun check(expression: FirTypeOperatorCall, context: CheckerContext, reporter: DiagnosticReporter) { val session = context.session val firstArgument = expression.argumentList.arguments[0] - val actualType = firstArgument.unwrapSmartcastExpression().coneType.fullyExpandedType(session) + val actualType = firstArgument.unwrapSmartcastExpression().resolvedType.fullyExpandedType(session) val conversionTypeRef = expression.conversionTypeRef val targetType = conversionTypeRef.coneType.fullyExpandedType(session) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt index 0d3b53f0ad4..7a0549bbcb1 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt @@ -49,8 +49,8 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { val markedNullable = source.getChild(QUEST, depth = 1) != null val isNullable = markedNullable || (argument as? FirResolvedQualifier)?.isNullableLHSForCallableReference == true || - argument.coneType.isMarkedNullable || - argument.coneType.isNullableTypeParameter(context.session.typeContext) + argument.resolvedType.isMarkedNullable || + argument.resolvedType.isNullableTypeParameter(context.session.typeContext) if (isNullable) { if (argument.canBeDoubleColonLHSAsType) { reporter.reportOn(source, FirErrors.NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, context) @@ -58,7 +58,7 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { reporter.reportOn( argument.source, FirErrors.EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, - argument.coneType, + argument.resolvedType, context ) } @@ -74,7 +74,8 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { if (argument !is FirResolvedQualifier) return // TODO, KT-59835: differentiate RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS - if (argument.typeArguments.isNotEmpty() && !argument.coneType.fullyExpandedType(context.session).isAllowedInClassLiteral(context)) { + if (argument.typeArguments.isNotEmpty() && !argument.resolvedType.fullyExpandedType(context.session) + .isAllowedInClassLiteral(context)) { val symbol = argument.symbol symbol?.lazyResolveToPhase(FirResolvePhase.TYPES) @OptIn(SymbolInternals::class) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirEqualityCompatibilityChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirEqualityCompatibilityChecker.kt index ec4fe97ce01..c5e52502fc8 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirEqualityCompatibilityChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirEqualityCompatibilityChecker.kt @@ -8,13 +8,13 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.KtRealSourceElementKind import org.jetbrains.kotlin.config.LanguageFeature -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory2 -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.collectUpperBounds +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass import org.jetbrains.kotlin.fir.declarations.utils.isFinal import org.jetbrains.kotlin.fir.declarations.utils.isInline @@ -352,10 +352,10 @@ private class ArgumentInfo( private val FirExpression.mostOriginalTypeIfSmartCast: ConeKotlinType get() = when (this) { is FirSmartCastExpression -> originalExpression.mostOriginalTypeIfSmartCast - else -> coneType + else -> resolvedType } private fun FirExpression.toArgumentInfo(context: CheckerContext) = ArgumentInfo( - this, coneType, mostOriginalTypeIfSmartCast.fullyExpandedType(context.session), context.session, + this, resolvedType, mostOriginalTypeIfSmartCast.fullyExpandedType(context.session), context.session, ) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExhaustiveWhenChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExhaustiveWhenChecker.kt index 7d2a9aa91d3..e11a9c8184c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExhaustiveWhenChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExhaustiveWhenChecker.kt @@ -25,9 +25,9 @@ import org.jetbrains.kotlin.fir.expressions.isExhaustive import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isBooleanOrNullableBoolean import org.jetbrains.kotlin.fir.types.lowerBoundIfFlexible +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol object FirExhaustiveWhenChecker : FirWhenExpressionChecker() { @@ -41,7 +41,7 @@ object FirExhaustiveWhenChecker : FirWhenExpressionChecker() { val source = whenExpression.source ?: return - val subjectType = whenExpression.subject?.coneType?.lowerBoundIfFlexible() + val subjectType = whenExpression.subject?.resolvedType?.lowerBoundIfFlexible() val subjectClassSymbol = subjectType?.fullyExpandedType(context.session)?.toRegularClassSymbol(context.session) if (whenExpression.usedAsExpression) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunctionReturnTypeMismatchChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunctionReturnTypeMismatchChecker.kt index a67be26cae2..f7f97cbc7db 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunctionReturnTypeMismatchChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunctionReturnTypeMismatchChecker.kt @@ -19,7 +19,10 @@ import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirErrorFunction import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor -import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.expressions.FirReturnExpression +import org.jetbrains.kotlin.fir.expressions.FirSmartCastExpression +import org.jetbrains.kotlin.fir.expressions.FirWhenExpression +import org.jetbrains.kotlin.fir.expressions.isExhaustive import org.jetbrains.kotlin.fir.types.* object FirFunctionReturnTypeMismatchChecker : FirReturnExpressionChecker() { @@ -56,7 +59,7 @@ object FirFunctionReturnTypeMismatchChecker : FirReturnExpressionChecker() { } val typeContext = context.session.typeContext - val returnExpressionType = resultExpression.coneType + val returnExpressionType = resultExpression.resolvedType if (!isSubtypeForTypeMismatch(typeContext, subtype = returnExpressionType, supertype = functionReturnType)) { if (resultExpression.isNullLiteral && functionReturnType.nullability == ConeNullability.NOT_NULL) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotNullAssertionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotNullAssertionChecker.kt index 1a49019fd54..4d733120296 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotNullAssertionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotNullAssertionChecker.kt @@ -6,16 +6,18 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.config.LanguageFeature -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.types.canBeNull +import org.jetbrains.kotlin.fir.types.isUnit +import org.jetbrains.kotlin.fir.types.resolvedType object FirNotNullAssertionChecker : FirCheckNotNullCallChecker() { override fun check(expression: FirCheckNotNullCall, context: CheckerContext, reporter: DiagnosticReporter) { @@ -30,12 +32,12 @@ object FirNotNullAssertionChecker : FirCheckNotNullCallChecker() { } // TODO: use of Unit is subject to change. // See BodyResolveComponents.typeForQualifier in ResolveUtils.kt which returns Unit for no value type. - if (argument is FirResolvedQualifier && argument.coneType.isUnit) { + if (argument is FirResolvedQualifier && argument.resolvedType.isUnit) { // Would be reported as NO_COMPANION_OBJECT return } - val type = argument.coneType.fullyExpandedType(context.session) + val type = argument.resolvedType.fullyExpandedType(context.session) if (!type.canBeNull && context.languageVersionSettings.supportsFeature(LanguageFeature.EnableDfaWarningsInK2)) { reporter.reportOn(expression.source, FirErrors.UNNECESSARY_NOT_NULL_ASSERTION, type, context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt index d8180b5edcb..31b5931419b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt @@ -11,11 +11,14 @@ import org.jetbrains.kotlin.fakeElement import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.isLhsOfAssignment import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment +import org.jetbrains.kotlin.fir.expressions.calleeReference import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression import org.jetbrains.kotlin.fir.references.toResolvedBaseSymbol import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType object FirOptInUsageAccessChecker : FirBasicExpressionChecker() { override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { @@ -35,7 +38,7 @@ object FirOptInUsageAccessChecker : FirBasicExpressionChecker() { reportNotAcceptedExperimentalities(experimentalities, expression.lValue, context, reporter) } else if (expression is FirQualifiedAccessExpression) { val dispatchReceiverType = - expression.dispatchReceiver.takeIf { it !is FirNoReceiverExpression }?.coneType?.fullyExpandedType(context.session) + expression.dispatchReceiver.takeIf { it !is FirNoReceiverExpression }?.resolvedType?.fullyExpandedType(context.session) val experimentalities = resolvedSymbol.loadExperimentalities(context, fromSetter = false, dispatchReceiverType) + loadExperimentalitiesFromTypeArguments(context, expression.typeArguments) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirReassignmentAndInvisibleSetterChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirReassignmentAndInvisibleSetterChecker.kt index 4073fa4e7f8..81dfb0ea944 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirReassignmentAndInvisibleSetterChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirReassignmentAndInvisibleSetterChecker.kt @@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.analysis.cfa.evaluatedInPlace import org.jetbrains.kotlin.fir.analysis.cfa.requiresInitialization import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.visibility @@ -25,7 +24,7 @@ import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeDiagnosticWithCandidates import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol import org.jetbrains.kotlin.fir.visibilityChecker @@ -64,7 +63,7 @@ object FirReassignmentAndInvisibleSetterChecker : FirVariableAssignmentChecker() val explicitReceiver = expression.explicitReceiver // Try to get type from smartcast if (explicitReceiver is FirSmartCastExpression) { - val symbol = explicitReceiver.originalExpression.coneType.toRegularClassSymbol(context.session) + val symbol = explicitReceiver.originalExpression.resolvedType.toRegularClassSymbol(context.session) if (symbol != null) { for (declarationSymbol in symbol.declarationSymbols) { if (declarationSymbol is FirPropertySymbol && declarationSymbol.name == callableSymbol.name) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirRecursiveProblemChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirRecursiveProblemChecker.kt index eb14bf3de90..24134fe8e8e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirRecursiveProblemChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirRecursiveProblemChecker.kt @@ -37,7 +37,7 @@ object FirRecursiveProblemChecker : FirBasicExpressionChecker() { } } - checkConeType(expression.coneType) + checkConeType(expression.resolvedType) } private val FirStatement.isExpressionWithAlwaysImplicitTypeRef get() = this is FirNoReceiverExpression diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSpreadOfNullableChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSpreadOfNullableChecker.kt index 76a02b56dd0..7a25515d6f3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSpreadOfNullableChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSpreadOfNullableChecker.kt @@ -6,22 +6,22 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression import org.jetbrains.kotlin.fir.types.ConeFlexibleType import org.jetbrains.kotlin.fir.types.canBeNull -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType object FirSpreadOfNullableChecker : FirFunctionCallChecker() { override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { fun checkAndReport(argument: FirExpression, source: KtSourceElement?) { - val coneType = argument.coneType + val coneType = argument.resolvedType if (argument is FirSpreadArgumentExpression && coneType !is ConeFlexibleType && coneType.canBeNull) { reporter.reportOn(source, FirErrors.SPREAD_OF_NULLABLE, context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt index 48d63b21f29..baa690634bd 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt @@ -7,19 +7,18 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.fullyExpandedClass import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol -import org.jetbrains.kotlin.fir.types.UnexpandedTypeCheck -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isUnit +import org.jetbrains.kotlin.fir.types.resolvedType object FirStandaloneQualifierChecker : FirResolvedQualifierChecker() { override fun check(expression: FirResolvedQualifier, context: CheckerContext, reporter: DiagnosticReporter) { @@ -30,7 +29,7 @@ object FirStandaloneQualifierChecker : FirResolvedQualifierChecker() { if (lastGetClass?.argument === expression) return // Note: if it's real Unit, it will be filtered by ClassKind.OBJECT check below in reportErrorOn - if (!expression.coneType.isUnit) return + if (!expression.resolvedType.isUnit) return expression.symbol.reportErrorOn(expression.source, context, reporter) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt index 024a2f93dd0..827cc21c7a0 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt @@ -21,9 +21,9 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.references.resolved import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol -import org.jetbrains.kotlin.fir.references.resolved import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol @@ -165,7 +165,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { expression.computeReceiversInfo(session, calledDeclarationSymbol) for (receiverExpression in listOfNotNull(dispatchReceiverExpression, extensionReceiverExpression)) { - if (!receiverExpression.coneType.isRestrictSuspensionReceiver(session)) continue + if (!receiverExpression.resolvedType.isRestrictSuspensionReceiver(session)) continue if (sameInstanceOfReceiver(receiverExpression, enclosingSuspendFunctionDispatchReceiverOwnerSymbol)) continue if (sameInstanceOfReceiver(receiverExpression, enclosingSuspendFunctionExtensionReceiverOwnerSymbol)) continue @@ -221,10 +221,10 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { calledDeclarationSymbol: FirCallableSymbol<*> ): Triple { if (this is FirImplicitInvokeCall && - dispatchReceiver != FirNoReceiverExpression && dispatchReceiver.coneType.isSuspendOrKSuspendFunctionType(session) + dispatchReceiver != FirNoReceiverExpression && dispatchReceiver.resolvedType.isSuspendOrKSuspendFunctionType(session) ) { val variableForInvoke = dispatchReceiver - val variableForInvokeType = variableForInvoke.coneType + val variableForInvokeType = variableForInvoke.resolvedType if (!variableForInvokeType.isExtensionFunctionType) return Triple(null, null, null) // `a.foo()` is resolved to invokeExtension, so it's been desugared to `foo.invoke(a)` diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirThrowExpressionTypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirThrowExpressionTypeChecker.kt index 1d6119937d7..da884ea452e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirThrowExpressionTypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirThrowExpressionTypeChecker.kt @@ -5,20 +5,17 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.FirThrowExpression -import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.isSubtypeOf -import org.jetbrains.kotlin.fir.types.isTypeMismatchDueToNullability -import org.jetbrains.kotlin.fir.types.typeContext +import org.jetbrains.kotlin.fir.types.* object FirThrowExpressionTypeChecker : FirThrowExpressionChecker() { override fun check(expression: FirThrowExpression, context: CheckerContext, reporter: DiagnosticReporter) { val expectedType = context.session.builtinTypes.throwableType.coneType - val actualType = expression.exception.coneType + val actualType = expression.exception.resolvedType if (!actualType.isSubtypeOf(expectedType, context.session)) { reporter.reportOn( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnnecessarySafeCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnnecessarySafeCallChecker.kt index f7794893f58..b94bf7fa521 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnnecessarySafeCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnnecessarySafeCallChecker.kt @@ -7,25 +7,19 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.config.LanguageFeature -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression -import org.jetbrains.kotlin.fir.expressions.calleeReference import org.jetbrains.kotlin.fir.languageVersionSettings -import org.jetbrains.kotlin.fir.references.resolved -import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -import org.jetbrains.kotlin.fir.types.ConeErrorType import org.jetbrains.kotlin.fir.types.canBeNull -import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.isUnit +import org.jetbrains.kotlin.fir.types.resolvedType object FirUnnecessarySafeCallChecker : FirSafeCallExpressionChecker() { override fun check(expression: FirSafeCallExpression, context: CheckerContext, reporter: DiagnosticReporter) { - val receiverType = expression.receiver.coneType.fullyExpandedType(context.session) + val receiverType = expression.receiver.resolvedType.fullyExpandedType(context.session) if (expression.receiver.source?.elementType == KtNodeTypes.SUPER_EXPRESSION) { reporter.reportOn(expression.source, FirErrors.UNEXPECTED_SAFE_CALL, context) return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt index 7ef09666b9c..53045d2fa08 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.declarations.utils.isCompanion import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toRegularClassSymbol object FirUnsupportedArrayLiteralChecker : FirArrayLiteralChecker() { @@ -36,7 +36,7 @@ object FirUnsupportedArrayLiteralChecker : FirArrayLiteralChecker() { context.callsOrAssignments.lastOrNull()?.let { val arguments = when (it) { is FirFunctionCall -> - if (it.coneType.toRegularClassSymbol(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) { + if (it.resolvedType.toRegularClassSymbol(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) { it.arguments } else { return false diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt index b0bc76cde24..6a19d995548 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt @@ -6,12 +6,8 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.checkers.FirTypeRefSource -import org.jetbrains.kotlin.fir.analysis.checkers.checkUpperBoundViolated +import org.jetbrains.kotlin.fir.analysis.checkers.* import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.withSource -import org.jetbrains.kotlin.fir.analysis.checkers.createSubstitutorForUpperBoundViolationCheck -import org.jetbrains.kotlin.fir.analysis.checkers.toTypeArgumentsWithSourceInfo import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference @@ -45,7 +41,7 @@ object FirUpperBoundViolatedExpressionChecker : FirQualifiedAccessExpressionChec val typeParameters: List if (calleeSymbol is FirConstructorSymbol && calleeSymbol.isTypeAliasedConstructor) { - val constructedType = expression.coneType.fullyExpandedType(context.session) + val constructedType = expression.resolvedType.fullyExpandedType(context.session) // Updating arguments with source information after expanding the type seems extremely brittle as it relies on identity equality // of the expression type arguments and the expanded type arguments. This cannot be applied before expanding the type because it // seems like the type is already expended. diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessElvisChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessElvisChecker.kt index 2ca42e89ba5..720391cb0bb 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessElvisChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessElvisChecker.kt @@ -6,24 +6,24 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.config.LanguageFeature -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.expressions.FirElvisExpression import org.jetbrains.kotlin.fir.types.ConeErrorType import org.jetbrains.kotlin.fir.types.canBeNull -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isNullLiteral +import org.jetbrains.kotlin.fir.types.resolvedType object FirUselessElvisChecker : FirElvisExpressionChecker() { override fun check(expression: FirElvisExpression, context: CheckerContext, reporter: DiagnosticReporter) { // If the overall expression is not resolved/completed, the corresponding error will be reported separately. // See [FirControlFlowStatementsResolveTransformer#transformElvisExpression], // where an error type is recorded as the expression's return type. - if (expression.coneType is ConeErrorType) return + if (expression.resolvedType is ConeErrorType) return - val lhsType = expression.lhs.coneType + val lhsType = expression.lhs.resolvedType if (lhsType is ConeErrorType) return if (!lhsType.canBeNull) { if (context.languageVersionSettings.supportsFeature(LanguageFeature.EnableDfaWarningsInK2)) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt index eb3c68ace2c..b86d1db725e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt @@ -23,7 +23,7 @@ object FirUselessTypeOperationCallChecker : FirTypeOperatorCallChecker() { if (expression.operation !in FirOperation.TYPES) return val arg = expression.argument - val candidateType = arg.coneType.upperBoundIfFlexible().fullyExpandedType(context.session) + val candidateType = arg.resolvedType.upperBoundIfFlexible().fullyExpandedType(context.session) if (candidateType is ConeErrorType) return val targetType = expression.conversionTypeRef.coneType.fullyExpandedType(context.session) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/ArrayEqualityCanBeReplacedWithEquals.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/ArrayEqualityCanBeReplacedWithEquals.kt index a6a9c785ff0..03d59853ab9 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/ArrayEqualityCanBeReplacedWithEquals.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/ArrayEqualityCanBeReplacedWithEquals.kt @@ -5,18 +5,18 @@ package org.jetbrains.kotlin.fir.analysis.checkers.extended +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirBasicExpressionChecker -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall import org.jetbrains.kotlin.fir.expressions.FirOperation import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.arguments -import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.fir.types.classId -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType +import org.jetbrains.kotlin.name.StandardClassIds object ArrayEqualityCanBeReplacedWithEquals : FirBasicExpressionChecker() { override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { @@ -26,8 +26,8 @@ object ArrayEqualityCanBeReplacedWithEquals : FirBasicExpressionChecker() { val left = arguments.getOrNull(0) ?: return val right = arguments.getOrNull(1) ?: return - if (left.coneType.classId != StandardClassIds.Array) return - if (right.coneType.classId != StandardClassIds.Array) return + if (left.resolvedType.classId != StandardClassIds.Array) return + if (right.resolvedType.classId != StandardClassIds.Array) return reporter.reportOn(expression.source, ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS, context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeReplacedWithOperatorAssignmentChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeReplacedWithOperatorAssignmentChecker.kt index 30f12cf849d..60ddf064a32 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeReplacedWithOperatorAssignmentChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeReplacedWithOperatorAssignmentChecker.kt @@ -23,8 +23,8 @@ import org.jetbrains.kotlin.fir.expressions.calleeReference import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isPrimitive +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.KtBinaryExpression import org.jetbrains.kotlin.psi.KtNameReferenceExpression @@ -39,7 +39,7 @@ object CanBeReplacedWithOperatorAssignmentChecker : FirVariableAssignmentChecker val rValue = expression.rValue as? FirFunctionCall ?: return if (rValue.source?.kind is KtFakeSourceElementKind) return - if (rValue.explicitReceiver?.coneType?.isPrimitive != true) return + if (rValue.explicitReceiver?.resolvedType?.isPrimitive != true) return val rValueResolvedSymbol = rValue.toResolvedCallableSymbol() ?: return if (rValueResolvedSymbol.dispatchReceiverClassTypeOrNull()?.isPrimitive != true) return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantCallOfConversionMethod.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantCallOfConversionMethod.kt index 58ce3059a62..95f2b1b47af 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantCallOfConversionMethod.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantCallOfConversionMethod.kt @@ -5,22 +5,22 @@ package org.jetbrains.kotlin.fir.analysis.checkers.extended +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirQualifiedAccessExpressionChecker -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.psi -import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.fir.types.ConeFlexibleType import org.jetbrains.kotlin.fir.types.classId -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isMarkedNullable +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.psi.KtSafeQualifiedExpression object RedundantCallOfConversionMethod : FirQualifiedAccessExpressionChecker() { @@ -36,14 +36,14 @@ object RedundantCallOfConversionMethod : FirQualifiedAccessExpressionChecker() { private fun FirExpression.isRedundant(qualifiedClassId: ClassId): Boolean { val thisType = if (this is FirConstExpression<*>) { - this.coneType.classId + this.resolvedType.classId } else { when { - coneType is ConeFlexibleType -> null + resolvedType is ConeFlexibleType -> null psi?.parent !is KtSafeQualifiedExpression - && (psi is KtSafeQualifiedExpression || coneType.isMarkedNullable) -> null - this.coneType.isMarkedNullable -> null - else -> this.coneType.classId + && (psi is KtSafeQualifiedExpression || resolvedType.isMarkedNullable) -> null + this.resolvedType.isMarkedNullable -> null + else -> this.resolvedType.classId } } return thisType == qualifiedClassId diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantSingleExpressionStringTemplateChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantSingleExpressionStringTemplateChecker.kt index d8389de3ddd..ab899cbfdc8 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantSingleExpressionStringTemplateChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantSingleExpressionStringTemplateChecker.kt @@ -9,18 +9,18 @@ import com.intellij.lang.LighterASTNode import com.intellij.lang.PsiBuilder import com.intellij.psi.PsiElement import org.jetbrains.kotlin.KtLightSourceElement -import org.jetbrains.kotlin.KtPsiSourceElement import org.jetbrains.kotlin.KtNodeTypes +import org.jetbrains.kotlin.KtPsiSourceElement +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirStringConcatenationCallChecker -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_SINGLE_EXPRESSION_STRING_TEMPLATE -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall import org.jetbrains.kotlin.fir.expressions.arguments import org.jetbrains.kotlin.fir.types.classId -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.psi.KtStringTemplateExpression import org.jetbrains.kotlin.util.getChildren @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.util.getChildren object RedundantSingleExpressionStringTemplateChecker : FirStringConcatenationCallChecker() { override fun check(expression: FirStringConcatenationCall, context: CheckerContext, reporter: DiagnosticReporter) { for (argumentExpression in expression.arguments) { - if (argumentExpression.coneType.classId == StandardClassIds.String && + if (argumentExpression.resolvedType.classId == StandardClassIds.String && argumentExpression.stringParentChildrenCount() == 1 // there is no more children in original string template ) { reporter.reportOn(argumentExpression.source, REDUNDANT_SINGLE_EXPRESSION_STRING_TEMPLATE, context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UselessCallOnNotNullChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UselessCallOnNotNullChecker.kt index ff4faf1cd78..0d2df12a4d0 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UselessCallOnNotNullChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UselessCallOnNotNullChecker.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.toResolvedNamedFunctionSymbol import org.jetbrains.kotlin.fir.types.ConeNullability import org.jetbrains.kotlin.fir.types.classId -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.name.CallableId object UselessCallOnNotNullChecker : FirQualifiedAccessExpressionChecker() { @@ -37,10 +37,10 @@ object UselessCallOnNotNullChecker : FirQualifiedAccessExpressionChecker() { } private fun FirExpression.getPackage(): String { - return coneType.classId?.packageFqName.toString() + return resolvedType.classId?.packageFqName.toString() } - private fun FirExpression.getNullability() = coneType.nullability + private fun FirExpression.getNullability() = resolvedType.nullability private val triggerOn = setOf( diff --git a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt index 463d9e681e1..a523dbb463e 100644 --- a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt +++ b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt @@ -1469,7 +1469,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver } private fun FlowContent.generate(unitExpression: FirUnitExpression) { - generate(unitExpression.coneType) + generate(unitExpression.resolvedType) } private fun FlowContent.generate(breakExpression: FirBreakExpression) { @@ -1530,7 +1530,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver } private fun FlowContent.generate(expression: FirExpression) { - exprType(expression.coneType.toFirResolvedTypeRef()) { + exprType(expression.resolvedType.toFirResolvedTypeRef()) { when (expression) { is FirBlock -> generateBlockIfAny(expression) is FirGetClassCall -> generate(expression) diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt index f2665a64eba..b9912d8f3ea 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor import org.jetbrains.kotlin.types.ConstantValueKind @@ -158,7 +159,7 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index f415b993f1c..094706542d1 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -11,7 +11,9 @@ import com.intellij.psi.tree.IElementType import org.jetbrains.kotlin.* import org.jetbrains.kotlin.backend.common.actualizer.IrActualizedResult import org.jetbrains.kotlin.builtins.StandardNames.DATA_CLASS_COMPONENT_PREFIX -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.ValueClassRepresentation import org.jetbrains.kotlin.diagnostics.startOffsetSkippingComments import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.builder.buildFileAnnotationsContainer @@ -28,8 +30,11 @@ import org.jetbrains.kotlin.fir.extensions.FirExtensionApiInternals import org.jetbrains.kotlin.fir.extensions.declarationGenerators import org.jetbrains.kotlin.fir.extensions.extensionService import org.jetbrains.kotlin.fir.extensions.generatedDeclarationsSymbolProvider -import org.jetbrains.kotlin.fir.references.* +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.references.FirThisReference import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolvedNamedReference +import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.calls.FirSimpleSyntheticPropertySymbol import org.jetbrains.kotlin.fir.resolve.providers.FirProvider @@ -246,7 +251,7 @@ private fun FirCallableSymbol<*>.toSymbolForCall( } // Member fake override or bound callable reference dispatchReceiver !is FirNoReceiverExpression -> { - val callSiteDispatchReceiverType = dispatchReceiver.coneType + val callSiteDispatchReceiverType = dispatchReceiver.resolvedType val declarationSiteDispatchReceiverType = dispatchReceiverType val type = if (callSiteDispatchReceiverType is ConeDynamicType && declarationSiteDispatchReceiverType != null) { declarationSiteDispatchReceiverType diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index d65d0b33587..9ff39afc5ba 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -933,7 +933,7 @@ class Fir2IrDeclarationStorage( firInitializerExpression: FirExpression?, type: IrType? = null ): IrField = convertCatching(property) { - val inferredType = type ?: firInitializerExpression!!.coneType.toIrType() + val inferredType = type ?: firInitializerExpression!!.resolvedType.toIrType() return declareIrField { symbol -> irFactory.createField( startOffset = startOffset, @@ -1101,7 +1101,7 @@ class Fir2IrDeclarationStorage( property.name, property.isVal, initializer, typeToUse ).also { field -> if (initializer is FirConstExpression<*>) { - val constType = initializer.coneType.toIrType() + val constType = initializer.resolvedType.toIrType() field.initializer = factory.createExpressionBody(initializer.toIrConst(constType)) } } @@ -1291,7 +1291,7 @@ class Fir2IrDeclarationStorage( return createIrField( field, irParent = irClass, - type = initializer?.coneType ?: field.returnTypeRef.coneType, + type = initializer?.resolvedType ?: field.returnTypeRef.coneType, origin = IrDeclarationOrigin.DELEGATE ).apply { metadata = FirMetadataSource.Field(field) @@ -1467,7 +1467,7 @@ class Fir2IrDeclarationStorage( // Note: for components call, we have to change type here (to original component type) to keep compatibility with PSI2IR // Some backend optimizations related to withIndex() probably depend on this type: index should always be Int // See e.g. forInStringWithIndexWithExplicitlyTypedIndexVariable.kt from codegen box tests - val type = ((variable.initializer as? FirComponentCall)?.coneType ?: variable.returnTypeRef.coneType).toIrType() + val type = ((variable.initializer as? FirComponentCall)?.resolvedType ?: variable.returnTypeRef.coneType).toIrType() // Some temporary variables are produced in RawFirBuilder, but we consistently use special names for them. val origin = when { givenOrigin != null -> givenOrigin @@ -1509,7 +1509,7 @@ class Fir2IrDeclarationStorage( enterScope(this) delegate = declareIrVariable( startOffset, endOffset, IrDeclarationOrigin.PROPERTY_DELEGATE, - NameUtils.propertyDelegateName(property.name), property.delegate!!.coneType.toIrType(), + NameUtils.propertyDelegateName(property.name), property.delegate!!.resolvedType.toIrType(), isVar = false, isConst = false, isLateinit = false ) delegate.parent = irParent diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt index 199dc3d24ba..022b4527438 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt @@ -10,8 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeAlias import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression import org.jetbrains.kotlin.fir.references.FirReference -import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol +import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor @@ -185,7 +185,7 @@ class Fir2IrImplicitCastInserter( } override fun visitThrowExpression(throwExpression: FirThrowExpression, data: IrElement): IrElement = - (data as IrThrow).cast(throwExpression, throwExpression.exception.coneType, throwExpression.coneType) + (data as IrThrow).cast(throwExpression, throwExpression.exception.resolvedType, throwExpression.resolvedType) override fun visitBlock(block: FirBlock, data: IrElement): IrElement = (data as? IrContainerExpression)?.insertImplicitCasts() ?: data @@ -193,7 +193,7 @@ class Fir2IrImplicitCastInserter( override fun visitReturnExpression(returnExpression: FirReturnExpression, data: IrElement): IrElement { val irReturn = data as? IrReturn ?: return data val expectedType = returnExpression.target.labeledElement.returnTypeRef - irReturn.value = irReturn.value.cast(returnExpression.result, returnExpression.result.coneType, expectedType.coneType) + irReturn.value = irReturn.value.cast(returnExpression.result, returnExpression.result.resolvedType, expectedType.coneType) return data } @@ -273,7 +273,7 @@ class Fir2IrImplicitCastInserter( override fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: IrElement): IrElement { // We don't want an implicit cast to Nothing?. This expression just encompasses nullability after null check. return if (smartCastExpression.isStable && smartCastExpression.smartcastTypeWithoutNullableNothing == null) { - implicitCastOrExpression(data as IrExpression, smartCastExpression.coneType) + implicitCastOrExpression(data as IrExpression, smartCastExpression.resolvedType) } else { data as IrExpression } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index 1cb659e254b..3dbc0b87dad 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -469,7 +469,7 @@ class Fir2IrVisitor( if (initializer != null) { irVariable.initializer = convertToIrExpression(initializer) - .insertImplicitCast(initializer, initializer.coneType, variable.returnTypeRef.coneType) + .insertImplicitCast(initializer, initializer.resolvedType, variable.returnTypeRef.coneType) } annotationGenerator.generate(irVariable, variable) return irVariable @@ -533,7 +533,7 @@ class Fir2IrVisitor( IrVarargImpl( startOffset, endOffset, - varargArgumentsExpression.coneType.toIrType(), + varargArgumentsExpression.resolvedType.toIrType(), varargArgumentsExpression.varargElementType.toIrType(), varargArgumentsExpression.arguments.map { it.convertToIrVarargElement() } ) @@ -566,7 +566,7 @@ class Fir2IrVisitor( val explicitReceiverExpression = convertToIrReceiverExpression(functionCall.explicitReceiver, functionCall.calleeReference) return callGenerator.convertToIrCall( functionCall, - functionCall.coneType, + functionCall.resolvedType, explicitReceiverExpression, dynamicOperator ) @@ -580,7 +580,7 @@ class Fir2IrVisitor( explicitReceiverExpression.arguments.removeLast() } val result = callGenerator.convertToIrCall( - functionCall, functionCall.coneType, explicitReceiverExpression, + functionCall, functionCall.resolvedType, explicitReceiverExpression, dynamicOperator = IrDynamicOperator.EQ ) if (result is IrDynamicOperatorExpression) { @@ -646,7 +646,7 @@ class Fir2IrVisitor( qualifiedAccessExpression.explicitReceiver, qualifiedAccessExpression.calleeReference ) return callGenerator.convertToIrCall( - qualifiedAccessExpression, qualifiedAccessExpression.coneType, explicitReceiverExpression + qualifiedAccessExpression, qualifiedAccessExpression.resolvedType, explicitReceiverExpression ) } @@ -714,7 +714,7 @@ class Fir2IrVisitor( IrGetFieldImpl( startOffset, endOffset, contextReceivers[calleeReference.contextReceiverNumber].symbol, - thisReceiverExpression.coneType.toIrType(), + thisReceiverExpression.resolvedType.toIrType(), thisRef, ) } @@ -771,7 +771,7 @@ class Fir2IrVisitor( return inaccessibleReceiverExpression.convertWithOffsets { startOffset, endOffset -> IrErrorExpressionImpl( startOffset, endOffset, - inaccessibleReceiverExpression.coneType.toIrType(), + inaccessibleReceiverExpression.resolvedType.toIrType(), "Receiver is inaccessible" ) } @@ -818,7 +818,7 @@ class Fir2IrVisitor( } override fun visitConstExpression(constExpression: FirConstExpression, data: Any?): IrElement { - return constExpression.toIrConst(constExpression.coneType.toIrType()) + return constExpression.toIrConst(constExpression.resolvedType.toIrType()) } // ================================================================================== @@ -873,7 +873,7 @@ class Fir2IrVisitor( calleeReference.name != OperatorNameConventions.INVOKE && (calleeReference.resolvedSymbol as? FirCallableSymbol)?.callableId?.callableName == OperatorNameConventions.INVOKE callGenerator.convertToIrCall( - expression, expression.coneType, explicitReceiverExpression = null, + expression, expression.resolvedType, explicitReceiverExpression = null, variableAsFunctionMode = variableAsFunctionMode ) } else { @@ -883,7 +883,7 @@ class Fir2IrVisitor( if (expression is FirQualifiedAccessExpression && expression.calleeReference is FirSuperReference) return@run this implicitCastInserter.implicitCastFromDispatchReceiver( - this, expression.coneType, calleeReference, + this, expression.resolvedType, calleeReference, conversionScope.defaultConversionTypeOrigin() ) } @@ -967,7 +967,7 @@ class Fir2IrVisitor( val receiver = statements.findFirst() ?: return null val receiverValue = receiver.initializer ?: return null - if (receiverValue.coneType !is ConeDynamicType) { + if (receiverValue.resolvedType !is ConeDynamicType) { return null } @@ -991,7 +991,7 @@ class Fir2IrVisitor( val arrayAccess = operationReceiver as? FirFunctionCall ?: return null val originalVararg = arrayAccess.resolvedArgumentMapping?.keys?.filterIsInstance()?.firstOrNull() (callGenerator.convertToIrCall( - arrayAccess, arrayAccess.coneType, + arrayAccess, arrayAccess.resolvedType, convertToIrReceiverExpression(receiverValue, arrayAccess.calleeReference), noArguments = true ) as IrDynamicOperatorExpression).apply { @@ -1010,12 +1010,12 @@ class Fir2IrVisitor( } callGenerator.convertToIrCall( qualifiedAccess, - qualifiedAccess.coneType, + qualifiedAccess.resolvedType, convertToIrReceiverExpression(receiverExpression, qualifiedAccess.calleeReference), ) } return callGenerator.convertToIrCall( - operationCall, operationCall.coneType, explicitReceiverExpression + operationCall, operationCall.resolvedType, explicitReceiverExpression ) } @@ -1055,7 +1055,7 @@ class Fir2IrVisitor( val type = if (forceUnitType) irBuiltIns.unitType else - (lastOrNull() as? FirExpression)?.coneType?.toIrType() ?: irBuiltIns.unitType + (lastOrNull() as? FirExpression)?.resolvedType?.toIrType() ?: irBuiltIns.unitType return source.convertWithOffsets { startOffset, endOffset -> if (origin == IrStatementOrigin.DO_WHILE_LOOP) { IrCompositeImpl( @@ -1080,7 +1080,7 @@ class Fir2IrVisitor( return errorExpression.convertWithOffsets { startOffset, endOffset -> IrErrorExpressionImpl( startOffset, endOffset, - errorExpression.coneType.toIrType(), + errorExpression.resolvedType.toIrType(), errorExpression.diagnostic.reason ) } @@ -1098,7 +1098,7 @@ class Fir2IrVisitor( source = elvisExpression.source moduleData = session.moduleData origin = FirDeclarationOrigin.Source - returnTypeRef = elvisExpression.lhs.coneType.toFirResolvedTypeRef() + returnTypeRef = elvisExpression.lhs.resolvedType.toFirResolvedTypeRef() name = Name.special("") initializer = elvisExpression.lhs symbol = FirPropertySymbol(name) @@ -1123,7 +1123,7 @@ class Fir2IrVisitor( IrConstImpl.constNull(startOffset, endOffset, irBuiltIns.nothingNType) ), convertToIrExpression(elvisExpression.rhs) - .insertImplicitCast(elvisExpression, elvisExpression.rhs.coneType, elvisExpression.coneType) + .insertImplicitCast(elvisExpression, elvisExpression.rhs.resolvedType, elvisExpression.resolvedType) ), IrElseBranchImpl( IrConstImpl.boolean(startOffset, endOffset, irBuiltIns.booleanType, true), @@ -1141,7 +1141,7 @@ class Fir2IrVisitor( generateWhen( startOffset, endOffset, IrStatementOrigin.ELVIS, irLhsVariable, irBranches, - elvisExpression.coneType.toIrType() + elvisExpression.resolvedType.toIrType() ) } } @@ -1167,7 +1167,7 @@ class Fir2IrVisitor( val whenExpressionType = if (whenExpression.isProperlyExhaustive && whenExpression.branches.none { it.condition is FirElseIfTrueCondition && it.result.statements.isEmpty() - }) whenExpression.coneType else session.builtinTypes.unitType.type + }) whenExpression.resolvedType else session.builtinTypes.unitType.type val irBranches = whenExpression.branches.mapTo(mutableListOf()) { branch -> branch.toIrWhenBranch(whenExpressionType) } @@ -1221,7 +1221,7 @@ class Fir2IrVisitor( private fun FirWhenBranch.toIrWhenBranch(whenExpressionType: ConeKotlinType): IrBranch { return convertWithOffsets { startOffset, endOffset -> val condition = condition - val irResult = convertToIrExpression(result).insertImplicitCast(result, result.coneType, whenExpressionType) + val irResult = convertToIrExpression(result).insertImplicitCast(result, result.resolvedType, whenExpressionType) if (condition is FirElseIfTrueCondition) { IrElseBranchImpl(IrConstImpl.boolean(irResult.startOffset, irResult.endOffset, irBuiltIns.booleanType, true), irResult) } else { @@ -1359,7 +1359,7 @@ class Fir2IrVisitor( // that line number for the finally block. return tryExpression.convertWithOffsets { startOffset, endOffset -> IrTryImpl( - startOffset, endOffset, tryExpression.coneType.toIrType(), + startOffset, endOffset, tryExpression.resolvedType.toIrType(), tryExpression.tryBlock.convertToIrBlock(forceUnitType = false), tryExpression.catches.map { it.accept(this, data) as IrCatch }, tryExpression.finallyBlock?.convertToIrBlock(forceUnitType = true) @@ -1443,13 +1443,13 @@ class Fir2IrVisitor( return checkNotNullCall.convertWithOffsets { startOffset, endOffset -> IrCallImpl( startOffset, endOffset, - checkNotNullCall.coneType.toIrType(), + checkNotNullCall.resolvedType.toIrType(), irBuiltIns.checkNotNullSymbol, typeArgumentsCount = 1, valueArgumentsCount = 1, origin = IrStatementOrigin.EXCLEXCL ).apply { - putTypeArgument(0, checkNotNullCall.argument.coneType.toIrType().makeNotNull()) + putTypeArgument(0, checkNotNullCall.argument.resolvedType.toIrType().makeNotNull()) putValueArgument(0, convertToIrExpression(checkNotNullCall.argument)) } } @@ -1457,12 +1457,12 @@ class Fir2IrVisitor( override fun visitGetClassCall(getClassCall: FirGetClassCall, data: Any?): IrElement = whileAnalysing(session, getClassCall) { val argument = getClassCall.argument - val irType = getClassCall.coneType.toIrType() + val irType = getClassCall.resolvedType.toIrType() val irClassType = if (argument is FirClassReferenceExpression) { argument.classTypeRef.toIrType() } else { - argument.coneType.toIrType() + argument.resolvedType.toIrType() } val irClassReferenceSymbol = when (argument) { is FirResolvedReifiedParameterReference -> { @@ -1510,7 +1510,7 @@ class Fir2IrVisitor( private fun convertToArrayLiteral(arrayLiteral: FirArrayLiteral): IrVararg { return arrayLiteral.convertWithOffsets { startOffset, endOffset -> - val arrayType = arrayLiteral.coneType.toIrType() + val arrayType = arrayLiteral.resolvedType.toIrType() val elementType = if (arrayLiteral.coneTypeOrNull != null) { arrayType.getArrayElementType(irBuiltIns) } else { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/PrimitiveComparison.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/PrimitiveComparison.kt index 939d190d6f2..3aa00e13379 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/PrimitiveComparison.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/PrimitiveComparison.kt @@ -9,8 +9,8 @@ import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.arguments -import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.name.StandardClassIds class PrimitiveConeNumericComparisonInfo( val comparisonType: ConeClassLikeType, @@ -28,8 +28,8 @@ fun FirComparisonExpression.inferPrimitiveNumericComparisonInfo(): PrimitiveCone inferPrimitiveNumericComparisonInfo(left, right) fun inferPrimitiveNumericComparisonInfo(left: FirExpression, right: FirExpression): PrimitiveConeNumericComparisonInfo? { - val leftType = left.coneType - val rightType = right.coneType + val leftType = left.resolvedType + val rightType = right.resolvedType val leftPrimitiveOrNullableType = leftType.getPrimitiveTypeOrSupertype() ?: return null val rightPrimitiveOrNullableType = rightType.getPrimitiveTypeOrSupertype() ?: return null val leastCommonType = leastCommonPrimitiveNumericType(leftPrimitiveOrNullableType, rightPrimitiveOrNullableType) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt index 33f94d93b9a..c115b7dcbd9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt @@ -450,7 +450,7 @@ internal class AdapterGenerator( if (!samType.isSamType) return this return IrTypeOperatorCallImpl( this.startOffset, this.endOffset, samType, IrTypeOperator.SAM_CONVERSION, samType, - castArgumentToFunctionalInterfaceForSamType(this, argument.coneType, samFirType) + castArgumentToFunctionalInterfaceForSamType(this, argument.resolvedType, samFirType) ) } @@ -556,7 +556,7 @@ internal class AdapterGenerator( session.typeContext.newTypeCheckerState( errorTypesEqualToAnything = false, stubTypesEqualToAnything = true ), - argument.coneType, + argument.resolvedType, parameter.returnTypeRef.coneType, isFromNullabilityConstraint = true ) @@ -638,7 +638,7 @@ internal class AdapterGenerator( expectedFunctionalType: ConeClassLikeType, argument: FirExpression ): IrSimpleFunctionSymbol? { - val argumentType = argument.coneType + val argumentType = argument.resolvedType val argumentTypeWithInvoke = argumentType.findSubtypeOfBasicFunctionType(session, expectedFunctionalType) ?: return null return if (argumentTypeWithInvoke.isSomeFunctionType(session)) { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 946f04dd2e6..51c6fe548f2 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -73,7 +73,7 @@ class CallAndReferenceGenerator( explicitReceiverExpression: IrExpression?, isDelegate: Boolean ): IrExpression { - val type = approximateFunctionReferenceType(callableReferenceAccess.coneType).toIrType() + val type = approximateFunctionReferenceType(callableReferenceAccess.resolvedType).toIrType() val callableSymbol = callableReferenceAccess.calleeReference.toResolvedCallableSymbol() if (callableSymbol?.origin == FirDeclarationOrigin.SamConstructor) { @@ -106,7 +106,7 @@ class CallAndReferenceGenerator( val referencedProperty = symbol.owner val referencedPropertyGetter = referencedProperty.getter val referencedPropertySetterSymbol = - if (callableReferenceAccess.coneType.isKMutableProperty(session)) referencedProperty.setter?.symbol + if (callableReferenceAccess.resolvedType.isKMutableProperty(session)) referencedProperty.setter?.symbol else null val backingFieldSymbol = when { referencedPropertyGetter != null -> null @@ -163,7 +163,7 @@ class CallAndReferenceGenerator( // Receivers are being applied inside with(adapterGenerator) { // TODO: Figure out why `adaptedType` is different from the `type`? - val adaptedType = callableReferenceAccess.coneType.toIrType() as IrSimpleType + val adaptedType = callableReferenceAccess.resolvedType.toIrType() as IrSimpleType generateAdaptedCallableReference(callableReferenceAccess, explicitReceiverExpression, symbol, adaptedType) } } else { @@ -791,13 +791,13 @@ class CallAndReferenceGenerator( qualifier: FirResolvedQualifier, callableReferenceAccess: FirCallableReferenceAccess? ): IrExpression? { - val classSymbol = (qualifier.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session) + val classSymbol = (qualifier.resolvedType as? ConeClassLikeType)?.lookupTag?.toSymbol(session) if (callableReferenceAccess?.isBound == false) { return null } - val irType = qualifier.coneType.toIrType() + val irType = qualifier.resolvedType.toIrType() return qualifier.convertWithOffsets { startOffset, endOffset -> if (classSymbol != null) { IrGetObjectValueImpl( @@ -1010,7 +1010,7 @@ class CallAndReferenceGenerator( var irArgument = visitor.convertToIrExpression(argument) if (parameter != null) { with(visitor.implicitCastInserter) { - irArgument = irArgument.cast(argument, argument.coneType, parameter.returnTypeRef.coneType) + irArgument = irArgument.cast(argument, argument.resolvedType, parameter.returnTypeRef.coneType) } } with(adapterGenerator) { @@ -1088,7 +1088,7 @@ class CallAndReferenceGenerator( ) if (conversionFunctions.isNotEmpty()) { elements.forEachIndexed { i, irVarargElement -> - val targetFun = argument.arguments[i].coneType.toIrType().classifierOrNull?.let { conversionFunctions[it] } + val targetFun = argument.arguments[i].resolvedType.toIrType().classifierOrNull?.let { conversionFunctions[it] } if (targetFun != null && irVarargElement is IrExpression) { elements[i] = irVarargElement.applyToElement(argument.arguments[i], targetFun) @@ -1103,7 +1103,7 @@ class CallAndReferenceGenerator( Name.identifier("to" + targetTypeFqName.shortName().asString()), StandardNames.BUILT_INS_PACKAGE_NAME.asString() ) - val sourceTypeClassifier = argument.coneType.toIrType().classifierOrNull ?: return this + val sourceTypeClassifier = argument.resolvedType.toIrType().classifierOrNull ?: return this val conversionFunction = conversionFunctions[sourceTypeClassifier] ?: return this @@ -1251,7 +1251,7 @@ class CallAndReferenceGenerator( with(visitor.implicitCastInserter) { it.cast( qualifiedAccess.extensionReceiver, - qualifiedAccess.extensionReceiver.coneType, + qualifiedAccess.extensionReceiver.resolvedType, receiverType.coneType, ) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt index db519daf493..378b6d4fc77 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt @@ -268,7 +268,11 @@ internal class ClassMemberGenerator( val irExpression = visitor.convertToIrExpression(initializerExpression, isDelegate = property.delegate != null) if (property.delegate == null) { with(visitor.implicitCastInserter) { - irExpression.cast(initializerExpression, initializerExpression.coneType, property.returnTypeRef.coneType) + irExpression.cast( + initializerExpression, + initializerExpression.resolvedType, + property.returnTypeRef.coneType + ) } } else { irExpression diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt index 6f100d72861..510a98a285a 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.lowerBoundIfFlexible +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrBlockBody import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl @@ -91,7 +92,7 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I memberRequiredPhase = null, ) - val delegateToScope = firField.initializer!!.coneType + val delegateToScope = firField.initializer!!.resolvedType .fullyExpandedType(session) .lowerBoundIfFlexible() .scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing, null) ?: return diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt index 35a6582539e..22f04d19d79 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/OperatorExpressionGenerator.kt @@ -8,9 +8,9 @@ package org.jetbrains.kotlin.fir.backend.generators import org.jetbrains.kotlin.fir.backend.* import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.types.ConeDynamicType -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isMarkedNullable import org.jetbrains.kotlin.fir.types.isNullable +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.ir.builders.primitiveOp1 import org.jetbrains.kotlin.ir.builders.primitiveOp2 import org.jetbrains.kotlin.ir.expressions.* @@ -46,7 +46,7 @@ internal class OperatorExpressionGenerator( val operation = comparisonExpression.operation val receiver = comparisonExpression.compareToCall.explicitReceiver - if (receiver?.coneType is ConeDynamicType) { + if (receiver?.resolvedType is ConeDynamicType) { val dynamicOperator = operation.toIrDynamicOperator() ?: throw Exception("Can't convert to the corresponding IrDynamicOperator") val argument = comparisonExpression.compareToCall.dynamicVarargArguments?.firstOrNull() @@ -241,7 +241,7 @@ internal class OperatorExpressionGenerator( comparisonInfo: PrimitiveConeNumericComparisonInfo?, isLeftType: Boolean ): IrExpression { - val isOriginalNullable = (this as? FirSmartCastExpression)?.originalExpression?.coneType?.isMarkedNullable ?: false + val isOriginalNullable = (this as? FirSmartCastExpression)?.originalExpression?.resolvedType?.isMarkedNullable ?: false val irExpression = visitor.convertToIrExpression(this) val operandType = if (isLeftType) comparisonInfo?.leftType else comparisonInfo?.rightType val targetType = comparisonInfo?.comparisonType diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt index 8a7b1bd22df..44f25cf3c80 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt @@ -10,7 +10,8 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.isAnnotationClass import org.jetbrains.kotlin.fir.backend.* -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter import org.jetbrains.kotlin.fir.declarations.utils.* @@ -18,12 +19,11 @@ import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.symbols.Fir2IrPropertySymbol import org.jetbrains.kotlin.fir.symbols.Fir2IrSimpleFunctionSymbol -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol import org.jetbrains.kotlin.ir.types.IrType @@ -98,7 +98,7 @@ class Fir2IrLazyProperty( containingClass?.classKind?.isAnnotationClass == true -> initializer?.asCompileTimeIrInitializer(components) // Setting initializers to every other class causes some cryptic errors in lowerings initializer is FirConstExpression<*> -> { - val constType = with(typeConverter) { initializer.coneType.toIrType() } + val constType = with(typeConverter) { initializer.resolvedType.toIrType() } factory.createExpressionBody(initializer.toIrConst(constType)) } else -> null diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt index 90b17dceae1..bfa03e1a851 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt @@ -95,7 +95,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko visitExpression(name, buildArrayLiteral { guessArrayTypeIfNeeded(name, elements)?.let { coneTypeOrNull = it.coneTypeOrNull - } ?: elements.firstOrNull()?.coneType?.createOutArrayType()?.let { + } ?: elements.firstOrNull()?.resolvedType?.createOutArrayType()?.let { coneTypeOrNull = it } argumentList = buildArgumentList { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt index 3e7c6b6ed3b..5f05ef35869 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt @@ -84,7 +84,7 @@ fun List.computeTypeAttributes( for (annotation in this) { val classId = when (shouldExpandTypeAliases) { true -> annotation.tryExpandClassId(session) - false -> annotation.coneType.classId + false -> annotation.resolvedType.classId } when (classId) { CompilerConeAttributes.Exact.ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes.Exact diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt index 22c0050771c..64f32662601 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt @@ -12,7 +12,6 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.declarations.utils.isStatic import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression import org.jetbrains.kotlin.fir.expressions.toReference @@ -287,7 +286,7 @@ abstract class FirVisibilityChecker : FirSessionComponent { val dispatchReceiverParameterClassLookupTag = dispatchReceiverParameterClassSymbol.toLookupTag() val dispatchReceiverValueOwnerLookupTag = - dispatchReceiver.coneType.findClassRepresentation( + dispatchReceiver.resolvedType.findClassRepresentation( dispatchReceiverParameterClassLookupTag.constructClassType( Array(dispatchReceiverParameterClassSymbol.fir.typeParameters.size) { ConeStarProjection }, isNullable = true @@ -364,10 +363,10 @@ abstract class FirVisibilityChecker : FirSessionComponent { session: FirSession ): Boolean { if (dispatchReceiver == null) return true - var dispatchReceiverType = dispatchReceiver.coneType + var dispatchReceiverType = dispatchReceiver.resolvedType if (dispatchReceiver is FirPropertyAccessExpression && dispatchReceiver.calleeReference is FirSuperReference) { // Special 'super' case: type of this, not of super, should be taken for the check below - dispatchReceiverType = dispatchReceiver.dispatchReceiver.coneType + dispatchReceiverType = dispatchReceiver.dispatchReceiver.resolvedType } val typeCheckerState = session.typeContext.newTypeCheckerState( errorTypesEqualToAnything = false, @@ -394,7 +393,7 @@ abstract class FirVisibilityChecker : FirSessionComponent { private fun FirExpression?.ownerIfCompanion(session: FirSession): ConeClassLikeLookupTag? = // TODO: what if there is an intersection type from smartcast? - (this?.coneType as? ConeClassLikeType)?.lookupTag?.ownerIfCompanion(session) + (this?.resolvedType as? ConeClassLikeType)?.lookupTag?.ownerIfCompanion(session) // monitorEnter/monitorExit are the only functions which are accessed "illegally" (see kotlin/util/Synchronized.kt). // Since they are intrinsified in the codegen, FIR should treat it as visible. @@ -508,7 +507,7 @@ private fun FirMemberDeclaration.containingNonLocalClass( if (dispatchReceiver != null) { val baseReceiverType = dispatchReceiverClassTypeOrNull() if (baseReceiverType != null) { - dispatchReceiver.coneType.findClassRepresentation(baseReceiverType, session)?.toSymbol(session)?.fir?.let { + dispatchReceiver.resolvedType.findClassRepresentation(baseReceiverType, session)?.toSymbol(session)?.fir?.let { return it } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt index f325bf777f8..03e416ea255 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt @@ -240,7 +240,7 @@ fun FirAnnotation.getKClassArgument(name: Name): ConeKotlinType? { } fun FirGetClassCall.getTargetType(): ConeKotlinType? { - return coneType.typeArguments.getOrNull(0)?.type + return resolvedType.typeArguments.getOrNull(0)?.type } fun FirAnnotationContainer.getJvmNameFromAnnotation(session: FirSession, target: AnnotationUseSiteTarget? = null): String? { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt index 7aa99208c84..5251849bea9 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt @@ -41,7 +41,7 @@ fun FirSmartCastExpression.smartcastScope( return smartcastScope } - val originalScope = originalExpression.coneType.scope( + val originalScope = originalExpression.resolvedType.scope( useSiteSession = useSiteSession, scopeSession = scopeSession, fakeOverrideTypeCalculator = FakeOverrideTypeCalculator.DoNothing, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 8517267fd8d..23c16ff0ee6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -585,7 +585,7 @@ class FirCallResolver( //calleeReference and annotationTypeRef are both error nodes so we need to avoid doubling of the diagnostic report else ConeStubDiagnostic( //prefer diagnostic with symbol, e.g. to use the symbol during navigation in IDE - (annotation.coneType as? ConeErrorType)?.diagnostic as? ConeDiagnosticWithSymbol<*> + (annotation.resolvedType as? ConeErrorType)?.diagnostic as? ConeDiagnosticWithSymbol<*> ?: ConeUnresolvedNameError(reference.name)), reference.source ) @@ -722,7 +722,7 @@ class FirCallResolver( ConeResolutionToClassifierError(singleExpectedCandidate!!, fir.symbol) } else -> { - val coneType = explicitReceiver?.coneType + val coneType = explicitReceiver?.resolvedType when { coneType != null && !coneType.isUnit -> { ConeFunctionExpectedError( @@ -751,7 +751,7 @@ class FirCallResolver( name.asString() == "invoke" && explicitReceiver is FirConstExpression<*> -> ConeFunctionExpectedError( explicitReceiver.value?.toString() ?: "", - explicitReceiver.coneType, + explicitReceiver.resolvedType, ) reference is FirSuperReference && (reference.superTypeRef.firClassLike(session) as? FirClass)?.isInterface == true -> ConeNoConstructorError else -> ConeUnresolvedNameError(name) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDoubleColonExpressionResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDoubleColonExpressionResolver.kt index 65bf96913d0..113c01a3888 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDoubleColonExpressionResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDoubleColonExpressionResolver.kt @@ -119,7 +119,7 @@ class FirDoubleColonExpressionResolver(private val session: FirSession) { } private fun resolveExpressionOnLHS(expression: FirExpression): DoubleColonLHS.Expression? { - val type = expression.coneType + val type = expression.resolvedType if (expression is FirResolvedQualifier) { val firClass = expression.expandedRegularClassIfAny() ?: return null diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index 81568d68acf..eb9f25acecb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -414,7 +414,7 @@ private fun BodyResolveComponents.transformExpressionUsingSm SmartcastStability.STABLE_VALUE } - val originalType = expression.coneType.fullyExpandedType(session) + val originalType = expression.resolvedType.fullyExpandedType(session) val allTypes = typesFromSmartCast.also { if (originalType !is ConeStubType) { it += originalType.fullyExpandedType(session) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt index 7742f2f21ea..ab9333dc291 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt @@ -147,7 +147,7 @@ private fun Candidate.resolveBlockArgument( checkApplicabilityForArgumentType( csBuilder, block, - block.coneType, + block.resolvedType, expectedType?.type, SimpleConstraintSystemConstraintPosition, isReceiver = false, @@ -513,7 +513,7 @@ private fun getExpectedTypeWithImplicintIntegerCoercion( val argumentType = if (argument.isIntegerLiteralOrOperatorCall()) { if (candidateExpectedType.fullyExpandedType(session).isUnsignedTypeOrNullableUnsignedType) - argument.coneType + argument.resolvedType else null } else { argument.calleeReference?.toResolvedCallableSymbol()?.takeIf { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt index c76b6c434aa..06cc0460939 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzerContext import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind @@ -135,7 +136,7 @@ class CandidateFactory private constructor( private fun FirExpression?.isCandidateFromCompanionObjectTypeScope(useSiteSession: FirSession): Boolean { val resolvedQualifier = this as? FirResolvedQualifier ?: return false - val originClassOfCandidate = this.coneType.classId ?: return false + val originClassOfCandidate = this.resolvedType.classId ?: return false val companion = resolvedQualifier.symbol?.fullyExpandedClass(useSiteSession)?.fir?.companionObjectSymbol return companion?.classId == originClassOfCandidate } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt index d36df65ca78..b766ba2076d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt @@ -25,7 +25,10 @@ import org.jetbrains.kotlin.fir.resolve.inference.csBuilder import org.jetbrains.kotlin.fir.resolve.inference.hasBuilderInferenceAnnotation import org.jetbrains.kotlin.fir.resolve.inference.model.ConeExplicitTypeParameterConstraintPosition import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.scopes.* +import org.jetbrains.kotlin.fir.scopes.FirTypeScope +import org.jetbrains.kotlin.fir.scopes.FirUnstableSmartcastTypeScope +import org.jetbrains.kotlin.fir.scopes.ProcessorAction +import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.SyntheticSymbol import org.jetbrains.kotlin.fir.symbols.impl.* @@ -137,7 +140,7 @@ private fun Candidate.prepareReceivers( context: ResolutionContext, ): ReceiverDescription { val argumentType = captureFromTypeParameterUpperBoundIfNeeded( - argumentType = argumentExtensionReceiver.coneType, + argumentType = argumentExtensionReceiver.resolvedType, expectedType = expectedType, session = context.session ).let { prepareCapturedType(it, context) } @@ -160,7 +163,7 @@ object CheckDispatchReceiver : ResolutionStage() { } } - val dispatchReceiverValueType = candidate.dispatchReceiver?.coneType ?: return + val dispatchReceiverValueType = candidate.dispatchReceiver?.resolvedType ?: return val isReceiverNullable = !AbstractNullabilityChecker.isSubtypeOfAny(context.session.typeContext, dispatchReceiverValueType) val isCandidateFromUnstableSmartcast = @@ -187,7 +190,10 @@ object CheckDispatchReceiver : ResolutionStage() { UnstableSmartCast( smartcastedReceiver, targetType, - context.session.typeContext.isTypeMismatchDueToNullability(smartcastedReceiver.originalExpression.coneType, targetType) + context.session.typeContext.isTypeMismatchDueToNullability( + smartcastedReceiver.originalExpression.resolvedType, + targetType + ) ) ) } else if (isReceiverNullable) { @@ -269,7 +275,7 @@ object CheckDslScopeViolation : ResolutionStage() { candidate, sink, context, - { getDslMarkersOfImplicitReceiver(thisReference.boundSymbol, receiver.coneType, context) } + { getDslMarkersOfImplicitReceiver(thisReference.boundSymbol, receiver.resolvedType, context) } ) { // Here we rely on the fact that receiver expression of implicit receiver value can not be changed // during resolution of one single call @@ -307,7 +313,7 @@ object CheckDslScopeViolation : ResolutionStage() { // ``` // `useX()` is a call to `invoke` with `useX` as the dispatch receiver. In the FIR tree, extension receiver is represented as an // implicit `this` expression passed as the first argument. - if (candidate.dispatchReceiver?.coneType?.fullyExpandedType(context.session)?.isSomeFunctionType(context.session) == true && + if (candidate.dispatchReceiver?.resolvedType?.fullyExpandedType(context.session)?.isSomeFunctionType(context.session) == true && (candidate.symbol as? FirNamedFunctionSymbol)?.name == OperatorNameConventions.INVOKE ) { val firstArg = candidate.argumentMapping?.keys?.firstOrNull() as? FirThisReceiverExpression ?: return @@ -376,7 +382,7 @@ object CheckDslScopeViolation : ResolutionStage() { private fun FirThisReceiverExpression.getDslMarkersOfThisReceiverExpression(context: ResolutionContext): Set { return buildSet { - collectDslMarkerAnnotations(context, coneType) + collectDslMarkerAnnotations(context, resolvedType) } } @@ -713,7 +719,7 @@ internal object ProcessDynamicExtensionAnnotation : ResolutionStage() { override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) { if (candidate.symbol.origin === FirDeclarationOrigin.DynamicScope) return val extensionReceiver = candidate.chosenExtensionReceiver ?: return - val argumentIsDynamic = extensionReceiver.coneType is ConeDynamicType + val argumentIsDynamic = extensionReceiver.resolvedType is ConeDynamicType val parameterIsDynamic = (candidate.symbol as? FirCallableSymbol)?.resolvedReceiverTypeRef?.type is ConeDynamicType if (parameterIsDynamic != argumentIsDynamic || parameterIsDynamic && !candidate.symbol.hasAnnotation(DYNAMIC_EXTENSION_ANNOTATION_CLASS_ID, context.session) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt index f173750a657..1c5fed31941 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt @@ -21,9 +21,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isNullableNothing import org.jetbrains.kotlin.fir.types.makeConeTypeDefinitelyNotNullOrNotNull +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.typeContext import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability import org.jetbrains.kotlin.utils.addToStdlib.runIf @@ -86,11 +86,11 @@ private fun removeSmartCastTypeForAttemptToFitVisibility(dispatchReceiver: FirEx val expressionWithSmartcastIfStable = (dispatchReceiver as? FirSmartCastExpression)?.takeIf { it.isStable } ?: return null - val receiverType = dispatchReceiver.coneType + val receiverType = dispatchReceiver.resolvedType if (receiverType.isNullableNothing) return null val originalExpression = expressionWithSmartcastIfStable.originalExpression - val originalType = originalExpression.coneType + val originalType = originalExpression.resolvedType val originalTypeNotNullable = originalType.makeConeTypeDefinitelyNotNullOrNotNull(session.typeContext) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt index ed36d5ecb64..c638b0b8ec2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt @@ -86,7 +86,7 @@ class MemberScopeTowerLevel( var (empty, candidates) = scope.collectCandidates(processScopeMembers) val scopeWithoutSmartcast = getOriginalReceiverExpressionIfStableSmartCast() - ?.coneType + ?.resolvedType ?.scope( session, scopeSession, @@ -383,7 +383,7 @@ class ScopeTowerLevel( ) return givenExtensionReceiverOptions.none { extensionReceiver -> - val extensionReceiverType = extensionReceiver.coneType + val extensionReceiverType = extensionReceiver.resolvedType // If some receiver is non class like, we should not skip it if (extensionReceiverType !is ConeClassLikeType) return@none true diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt index 80c28f4b80b..bc6e2c4efc4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt @@ -404,8 +404,8 @@ abstract class FirDataFlowAnalyzer( val rightConst = rightOperand as? FirConstExpression<*> val leftIsNullConst = leftConst?.kind == ConstantValueKind.Null val rightIsNullConst = rightConst?.kind == ConstantValueKind.Null - val leftIsNull = leftIsNullConst || leftOperand.coneType.isNullableNothing && !rightIsNullConst - val rightIsNull = rightIsNullConst || rightOperand.coneType.isNullableNothing && !leftIsNullConst + val leftIsNull = leftIsNullConst || leftOperand.resolvedType.isNullableNothing && !rightIsNullConst + val rightIsNull = rightIsNullConst || rightOperand.resolvedType.isNullableNothing && !leftIsNullConst node.mergeIncomingFlow { _, flow -> when { @@ -432,10 +432,10 @@ abstract class FirDataFlowAnalyzer( val operandVariable = variableStorage.getOrCreateIfReal(flow, operand) ?: return val expressionVariable = variableStorage.createSynthetic(expression) - if (const.kind == ConstantValueKind.Boolean && operand.coneType.isBooleanOrNullableBoolean) { + if (const.kind == ConstantValueKind.Boolean && operand.resolvedType.isBooleanOrNullableBoolean) { val expected = (const.value as Boolean) flow.addImplication((expressionVariable eq isEq) implies (operandVariable eq expected)) - if (operand.coneType.isBoolean) { + if (operand.resolvedType.isBoolean) { flow.addImplication((expressionVariable eq !isEq) implies (operandVariable eq !expected)) } } else { @@ -459,8 +459,8 @@ abstract class FirDataFlowAnalyzer( operation: FirOperation, ) { val isEq = operation.isEq() - val leftOperandType = leftOperand.coneType - val rightOperandType = rightOperand.coneType + val leftOperandType = leftOperand.resolvedType + val rightOperandType = rightOperand.resolvedType val leftIsNullable = leftOperandType.isMarkedNullable val rightIsNullable = rightOperandType.isMarkedNullable @@ -581,7 +581,7 @@ abstract class FirDataFlowAnalyzer( private fun CFGNode<*>.mergeWhenBranchEntryFlow() = mergeIncomingFlow { _, flow -> val previousConditionExitNode = previousNodes.singleOrNull() as? WhenBranchConditionExitNode ?: return@mergeIncomingFlow val previousCondition = previousConditionExitNode.fir.condition - if (!previousCondition.coneType.isBoolean) return@mergeIncomingFlow + if (!previousCondition.resolvedType.isBoolean) return@mergeIncomingFlow val previousConditionVariable = variableStorage.get(flow, previousCondition) ?: return@mergeIncomingFlow flow.commitOperationStatement(previousConditionVariable eq false) } @@ -591,7 +591,7 @@ abstract class FirDataFlowAnalyzer( conditionExitNode.mergeIncomingFlow() resultEnterNode.mergeIncomingFlow { _, flow -> // If the condition is invalid, don't generate smart casts to Any or Boolean. - if (whenBranch.condition.coneType.isBoolean) { + if (whenBranch.condition.resolvedType.isBoolean) { val conditionVariable = variableStorage.get(flow, whenBranch.condition) ?: return@mergeIncomingFlow flow.commitOperationStatement(conditionVariable eq true) } @@ -624,7 +624,7 @@ abstract class FirDataFlowAnalyzer( val (loopConditionExitNode, loopBlockEnterNode) = graphBuilder.exitWhileLoopCondition(loop) loopConditionExitNode.mergeIncomingFlow() loopBlockEnterNode.mergeIncomingFlow { _, flow -> - if (loop.condition.coneType.isBoolean) { + if (loop.condition.resolvedType.isBoolean) { val conditionVariable = variableStorage.get(flow, loop.condition) ?: return@mergeIncomingFlow flow.commitOperationStatement(conditionVariable eq true) } @@ -668,7 +668,7 @@ abstract class FirDataFlowAnalyzer( private fun processLoopExit(flow: MutableFlow, node: LoopExitNode, conditionExitNode: LoopConditionExitNode) { if (conditionExitNode.isDead || node.previousNodes.count { !it.isDead } > 1) return - if (conditionExitNode.fir.coneType.isBoolean) { + if (conditionExitNode.fir.resolvedType.isBoolean) { val variable = variableStorage.get(flow, conditionExitNode.fir) ?: return flow.commitOperationStatement(variable eq false) } @@ -973,7 +973,7 @@ abstract class FirDataFlowAnalyzer( if (isAssignment) { // `propertyVariable` can be an alias to `initializerVariable`, in which case this will add // a redundant type statement which is fine...probably - flow.addTypeStatement(flow.unwrapVariable(propertyVariable) typeEq initializer.coneType) + flow.addTypeStatement(flow.unwrapVariable(propertyVariable) typeEq initializer.resolvedType) } } @@ -1014,7 +1014,7 @@ abstract class FirDataFlowAnalyzer( val flowFromRight = rightOperandNode.getFlow(path) val leftVariable = variableStorage.get(flowFromLeft, fir.leftOperand) - val leftIsBoolean = leftVariable != null && fir.leftOperand.coneType.isBoolean + val leftIsBoolean = leftVariable != null && fir.leftOperand.resolvedType.isBoolean if (!leftOperandNode.isDead && rightOperandNode.isDead) { // If the right operand does not terminate, then we know that the value of the entire expression // has to be saturating (true for or, false for and), and it has to be produced by the left operand. @@ -1024,7 +1024,7 @@ abstract class FirDataFlowAnalyzer( } } else { val rightVariable = variableStorage.get(flowFromRight, fir.rightOperand) - val rightIsBoolean = rightVariable != null && fir.rightOperand.coneType.isBoolean + val rightIsBoolean = rightVariable != null && fir.rightOperand.resolvedType.isBoolean val operatorVariable = variableStorage.createSynthetic(fir) // If `left && right` is true, then both are evaluated to true. If `left || right` is false, then both are false. // Approved type statements for RHS already contain everything implied by the corresponding value of LHS. diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt index 8394651ff7c..50c3a0d34d4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt @@ -78,8 +78,8 @@ class FirBuilderInferenceSession( val dispatchReceiver = dispatchReceiver return when { extensionReceiver == null && dispatchReceiver == null -> false - dispatchReceiver?.coneType?.containsStubType() == true -> true - extensionReceiver?.coneType?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation(session) + dispatchReceiver?.resolvedType?.containsStubType() == true -> true + extensionReceiver?.resolvedType?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation(session) else -> false } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt index 671d74173a1..e7b2389d42b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt @@ -10,7 +10,10 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvable import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.calls.* import org.jetbrains.kotlin.fir.resolve.inference.model.ConeFixVariableConstraintPosition -import org.jetbrains.kotlin.fir.resolve.substitution.* +import org.jetbrains.kotlin.fir.resolve.substitution.ChainedSubstitutor +import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor +import org.jetbrains.kotlin.fir.resolve.substitution.NotFixedTypeToVariableSubstitutorForDelegateInference +import org.jetbrains.kotlin.fir.resolve.substitution.replaceStubsAndTypeVariablesToErrors import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder import org.jetbrains.kotlin.resolve.calls.inference.NewConstraintSystem @@ -72,8 +75,8 @@ class FirDelegatedPropertyInferenceSession( if (callee.candidate.system.hasContradiction) return true val hasStubType = - callee.candidate.chosenExtensionReceiver?.coneType?.containsStubType() ?: false - || callee.candidate.dispatchReceiver?.coneType?.containsStubType() ?: false + callee.candidate.chosenExtensionReceiver?.resolvedType?.containsStubType() ?: false + || callee.candidate.dispatchReceiver?.resolvedType?.containsStubType() ?: false if (!hasStubType) { return true diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index 9b69efa0587..f39f1c1d386 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -195,7 +195,7 @@ class FirCallCompletionResultsWriterTransformer( ?: return functionCall val result = prepareQualifiedTransform(functionCall, calleeReference) val subCandidate = calleeReference.candidate - val resultType = result.coneType.substituteType(subCandidate) + val resultType = result.resolvedType.substituteType(subCandidate) if (calleeReference.isError) { subCandidate.argumentMapping?.let { result.replaceArgumentList(buildArgumentListForErrorCall(result.argumentList, it)) @@ -352,7 +352,7 @@ class FirCallCompletionResultsWriterTransformer( val subCandidate = calleeReference.candidate val typeArguments = computeTypeArguments(callableReferenceAccess, subCandidate) - val initialType = calleeReference.candidate.substitutor.substituteOrSelf(callableReferenceAccess.coneType) + val initialType = calleeReference.candidate.substitutor.substituteOrSelf(callableReferenceAccess.resolvedType) val finalType = finallySubstituteOrSelf(initialType) callableReferenceAccess.replaceConeTypeOrNull(finalType) @@ -394,7 +394,7 @@ class FirCallCompletionResultsWriterTransformer( qualifiedAccessExpression: FirQualifiedAccessExpression, data: Any? ): FirStatement { - val originalType = qualifiedAccessExpression.coneType + val originalType = qualifiedAccessExpression.resolvedType val substitutedReceiverType = finallySubstituteOrNull(originalType) ?: return qualifiedAccessExpression qualifiedAccessExpression.replaceConeTypeOrNull(substitutedReceiverType) session.lookupTracker?.recordTypeResolveAsLookup(substitutedReceiverType, qualifiedAccessExpression.source, context.file.source) @@ -570,7 +570,7 @@ class FirCallCompletionResultsWriterTransformer( // Prefer the expected type over the inferred one - the latter is a subtype of the former in valid code, // and there will be ARGUMENT_TYPE_MISMATCH errors on the lambda's return expressions in invalid code. val resultReturnType = expectedReturnType - ?: session.typeContext.commonSuperTypeOrNull(returnExpressions.map { it.coneType }) + ?: session.typeContext.commonSuperTypeOrNull(returnExpressions.map { it.resolvedType }) ?: session.builtinTypes.unitType.type if (initialReturnType != resultReturnType) { @@ -702,7 +702,7 @@ class FirCallCompletionResultsWriterTransformer( syntheticCall: D, data: ExpectedArgumentType? ) where D : FirResolvable, D : FirExpression { - val newData = data?.getExpectedType(syntheticCall)?.toExpectedType() ?: syntheticCall.coneType.toExpectedType() + val newData = data?.getExpectedType(syntheticCall)?.toExpectedType() ?: syntheticCall.resolvedType.toExpectedType() if (syntheticCall is FirTryExpression) { syntheticCall.transformCalleeReference(this, newData) @@ -747,7 +747,7 @@ class FirCallCompletionResultsWriterTransformer( val expectedArrayElementType = expectedArrayType?.arrayElementType() arrayLiteral.transformChildren(this, expectedArrayElementType?.toExpectedType()) val arrayElementType = - session.typeContext.commonSuperTypeOrNull(arrayLiteral.arguments.map { it.coneType })?.let { + session.typeContext.commonSuperTypeOrNull(arrayLiteral.arguments.map { it.resolvedType })?.let { typeApproximator.approximateToSuperType(it, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference) ?: it } ?: expectedArrayElementType ?: session.builtinTypes.nullableAnyType.type diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt index f56514002a7..13624899c99 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt @@ -54,7 +54,7 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe private fun getSubjectType(session: FirSession, whenExpression: FirWhenExpression): ConeKotlinType? { val subjectType = whenExpression.subjectVariable?.returnTypeRef?.coneType - ?: whenExpression.subject?.coneType + ?: whenExpression.subject?.resolvedType ?: return null return subjectType.fullyExpandedType(session).lowerBoundIfFlexible() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index d0edacea035..988d555dc50 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt @@ -64,7 +64,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirAbstractBodyRes return context.withWhenExpression(whenExpression, session) with@{ @Suppress("NAME_SHADOWING") var whenExpression = whenExpression.transformSubject(transformer, ResolutionMode.ContextIndependent) - val subjectType = whenExpression.subject?.coneType?.fullyExpandedType(session) + val subjectType = whenExpression.subject?.resolvedType?.fullyExpandedType(session) var completionNeeded = false context.withWhenSubjectType(subjectType, components) { when { @@ -281,7 +281,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirAbstractBodyRes // Sometimes return type for special call for elvis operator might be nullable, // but result is not nullable if the right type is not nullable result.replaceConeTypeOrNull( - result.coneType.makeConeTypeDefinitelyNotNullOrNotNull(session.typeContext) + result.resolvedType.makeConeTypeDefinitelyNotNullOrNotNull(session.typeContext) ) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 9ed99f18f0c..24be5da2774 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -343,7 +343,7 @@ open class FirDeclarationsResolveTransformer( val substitutor = createTypeSubstitutorByTypeConstructor( typeVariableTypeToStubType, session.typeContext, approximateIntegerLiterals = true ) - val delegateExpressionType = delegateExpression.coneType + val delegateExpressionType = delegateExpression.resolvedType val stubTypeSubstituted = substitutor.substituteOrNull(delegateExpressionType) delegateExpression.replaceConeTypeOrNull(stubTypeSubstituted) } @@ -880,7 +880,7 @@ open class FirDeclarationsResolveTransformer( // In correct code this doesn't matter, as all return expression types should be subtypes of the expected type. // In incorrect code, this would change diagnostics: we can get errors either on the entire lambda, or only on its // return statements. The former kind of makes more sense, but the latter is more readable. - val inferredFromReturnExpressions = session.typeContext.commonSuperTypeOrNull(returnExpressions.map { it.expression.coneType }) + val inferredFromReturnExpressions = session.typeContext.commonSuperTypeOrNull(returnExpressions.map { it.expression.resolvedType }) return inferredFromReturnExpressions?.let { returnTypeRef.resolvedTypeFromPrototype(it) } ?: session.builtinTypes.unitType // Empty lambda returns Unit } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 0662079bc47..857bdfb620e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -604,13 +604,13 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT fun operatorReturnTypeMatches(candidate: Candidate): Boolean { // After KT-45503, non-assign flavor of operator is checked more strictly: the return type must be assignable to the variable. - val operatorCallReturnType = resolvedOperatorCall.coneType + val operatorCallReturnType = resolvedOperatorCall.resolvedType val substitutor = candidate.system.currentStorage() .buildAbstractResultingSubstitutor(candidate.system.typeSystemContext) as ConeSubstitutor return AbstractTypeChecker.isSubtypeOf( session.typeContext, substitutor.substituteOrSelf(operatorCallReturnType), - leftArgument.coneType + leftArgument.resolvedType ) } // following `!!` is safe since `operatorIsSuccessful = true` implies `operatorCallReference != null` @@ -691,7 +691,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT !assignIsSuccessful && !operatorIsSuccessful -> chooseResolved() !assignIsSuccessful && operatorIsSuccessful -> chooseOperator() assignIsSuccessful && !operatorIsSuccessful -> chooseAssign() - leftArgument.coneType is ConeDynamicType -> chooseAssign() + leftArgument.resolvedType is ConeDynamicType -> chooseAssign() !operatorReturnTypeMatches -> chooseAssign() else -> reportAmbiguity() } @@ -1117,7 +1117,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT ) type } else { - lhs.coneType + lhs.resolvedType } } is FirResolvedReifiedParameterReference -> { @@ -1189,7 +1189,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>) constExpression.resultType = type - return when (val resolvedType = constExpression.coneType) { + return when (val resolvedType = constExpression.resolvedType) { is ConeErrorType -> buildErrorExpression { expression = constExpression diagnostic = resolvedType.diagnostic diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt index 030f648a5e4..e60dd61960a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.contracts import org.jetbrains.kotlin.contracts.description.* -import org.jetbrains.kotlin.contracts.description.LogicOperationKind import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.contracts.description.* @@ -20,6 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.getContainingClass import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.types.toSymbol import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor import org.jetbrains.kotlin.name.CallableId @@ -194,7 +194,7 @@ class ConeEffectExtractor( val ownerHasReceiver = callableOwner?.receiverParameter != null val ownerIsMemberOfDeclaration = callableOwner?.getContainingClass(session) == declaration return if (declaration == owner || owner.isAccessorOf(declaration) || ownerIsMemberOfDeclaration && !ownerHasReceiver) { - val type = thisReceiverExpression.coneType + val type = thisReceiverExpression.resolvedType toValueParameterReference(type, -1, "this") } else { ConeContractDescriptionError.IllegalThis(thisReceiverExpression).asElement() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt index de45175d4c5..7605e507dc4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt @@ -354,7 +354,7 @@ class FirExpectActualMatchingContextImpl private constructor( } private fun areFirAnnotationsEqual(annotation1: FirAnnotation, annotation2: FirAnnotation): Boolean { - if (!areCompatibleExpectActualTypes(annotation1.coneType, annotation2.coneType)) { + if (!areCompatibleExpectActualTypes(annotation1.resolvedType, annotation2.resolvedType)) { return false } val args1 = annotation1.argumentMapping.mapping diff --git a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt index 56b8d247535..831df46be80 100644 --- a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt +++ b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt @@ -17,9 +17,9 @@ import org.jetbrains.kotlin.fir.resolve.dfa.PersistentFlow import org.jetbrains.kotlin.fir.resolve.dfa.controlFlowGraph import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.constructClassLikeType import org.jetbrains.kotlin.fir.types.isNothing +import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.StandardClassIds @@ -893,7 +893,7 @@ class FakeExpressionEnterNode(owner: ControlFlowGraph, level: Int) : CFGNode(owner, level) { override val canThrow: Boolean - get() = fir.coneType.isNothing + get() = fir.resolvedType.isNothing override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitSmartCastExpressionExitNode(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt index 768b7106faa..2f91182491e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt @@ -37,7 +37,7 @@ val FirTypeRef.coneType: ConeKotlinType val FirTypeRef.coneTypeOrNull: ConeKotlinType? get() = coneTypeSafe() -val FirExpression.coneType: ConeKotlinType get() = requireNotNull(coneTypeOrNull) { "Expected type to be resolved" } +val FirExpression.resolvedType: ConeKotlinType get() = requireNotNull(coneTypeOrNull) { "Expected type to be resolved" } inline fun FirExpression.coneTypeSafe(): T? = (coneTypeOrNull as? T) diff --git a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt index 162104b2414..3ccf768da9e 100644 --- a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt +++ b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt @@ -164,7 +164,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { if (function.isLocal) stack.addName(function.name ?: ANONYMOUS_NAME) stack.push((function.name ?: ANONYMOUS_NAME)) if (function.equalsToken != null) { - function.bodyExpression!!.firstOfTypeWithRender(function.equalsToken) { this.result.coneType.toFirResolvedTypeRef() } + function.bodyExpression!!.firstOfTypeWithRender(function.equalsToken) { this.result.resolvedType.toFirResolvedTypeRef() } ?: function.firstOfTypeWithRender(function.equalsToken) { this.returnTypeRef } } super.visitNamedFunction(function) @@ -249,12 +249,12 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { } override fun visitIfExpression(expression: KtIfExpression) { - expression.firstOfTypeWithRender { this.coneType.toFirResolvedTypeRef() } + expression.firstOfTypeWithRender { this.resolvedType.toFirResolvedTypeRef() } super.visitIfExpression(expression) } override fun visitWhenExpression(expression: KtWhenExpression) { - expression.firstOfTypeWithRender { this.coneType.toFirResolvedTypeRef() } + expression.firstOfTypeWithRender { this.resolvedType.toFirResolvedTypeRef() } super.visitWhenExpression(expression) } @@ -306,7 +306,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { } override fun visitWhenEntry(ktWhenEntry: KtWhenEntry) { - ktWhenEntry.firstOfTypeWithRender(ktWhenEntry.expression) { this.result.coneType.toFirResolvedTypeRef() } + ktWhenEntry.firstOfTypeWithRender(ktWhenEntry.expression) { this.result.resolvedType.toFirResolvedTypeRef() } super.visitWhenEntry(ktWhenEntry) } @@ -564,7 +564,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { fir.receiverParameter?.accept(this, data) data.append(".").append(callableName) } - call.dispatchReceiver.coneType.isExtensionFunctionType -> { + call.dispatchReceiver.resolvedType.isExtensionFunctionType -> { withExtensionFunctionType = true fir.valueParameters.first().returnTypeRef.accept(this, data) data.append(".").append(callableName) @@ -786,7 +786,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { override fun visitConstExpression(constExpression: FirConstExpression, data: StringBuilder) { when (constExpression.kind) { ConstantValueKind.String -> return - ConstantValueKind.Null -> constExpression.coneType.tryToRenderConeAsFunctionType(data) + ConstantValueKind.Null -> constExpression.resolvedType.tryToRenderConeAsFunctionType(data) else -> data.append(constExpression.kind) } } @@ -796,7 +796,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { when { fir is FirRegularClass && fir.classKind != ClassKind.ENUM_CLASS && fir.companionObjectSymbol?.defaultType() == resolvedQualifier.coneTypeSafe() -> { data.append("companion object ") - data.append(resolvedQualifier.coneType.toFirResolvedTypeRef().render()).append(": ") + data.append(resolvedQualifier.resolvedType.toFirResolvedTypeRef().render()).append(": ") data.append(fir.symbol.classId.asString().removeCurrentFilePackage()) } fir is FirClass -> { @@ -845,8 +845,8 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { } override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: StringBuilder) { - val name = arrayLiteral.coneType.classId!!.shortClassName.asString() - val typeArguments = arrayLiteral.coneType.typeArguments + val name = arrayLiteral.resolvedType.classId!!.shortClassName.asString() + val typeArguments = arrayLiteral.resolvedType.typeArguments val typeParameters = if (typeArguments.isEmpty()) "" else " " data.append("fun$typeParameters ${name.replaceFirstChar(Char::lowercaseChar)}Of") typeArguments.firstOrNull()?.let { diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/checkers/SignedNumberCallChecker.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/checkers/SignedNumberCallChecker.kt index c6ce7ee5a4a..0785ceb977b 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/checkers/SignedNumberCallChecker.kt +++ b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/checkers/SignedNumberCallChecker.kt @@ -5,16 +5,17 @@ package org.jetbrains.kotlin.fir.plugin.checkers -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.InternalDiagnosticFactoryMethod import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.resolvedArgumentMapping import org.jetbrains.kotlin.fir.plugin.types.ConeNumberSignAttribute import org.jetbrains.kotlin.fir.plugin.types.numberSign import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.resolvedType object SignedNumberCallChecker : FirFunctionCallChecker() { @OptIn(InternalDiagnosticFactoryMethod::class) @@ -22,7 +23,7 @@ object SignedNumberCallChecker : FirFunctionCallChecker() { val argumentMapping = expression.resolvedArgumentMapping ?: return for ((argument, parameter) in argumentMapping.entries) { val expectedSign = parameter.returnTypeRef.coneType.attributes.numberSign ?: continue - val actualSign = argument.coneType.attributes.numberSign + val actualSign = argument.resolvedType.attributes.numberSign if (expectedSign != actualSign) { reporter.reportOn( argument.source, PluginErrors.ILLEGAL_NUMBER_SIGN, expectedSign.asString(), actualSign.asString(), context diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt index 3cb45630270..bb7dd38138a 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt @@ -175,8 +175,8 @@ object FirSerializationPluginClassChecker : FirClassChecker() { this is FirConstExpression<*> && other is FirConstExpression<*> -> kind == other.kind && value == other.value this is FirGetClassCall && other is FirGetClassCall -> AbstractTypeChecker.equalTypes( session.typeContext, - coneType, - other.coneType + resolvedType, + other.resolvedType ) this is FirPropertyAccessExpression && other is FirPropertyAccessExpression ->