diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt index f8b96dbc1aa..2eed0728905 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt @@ -128,7 +128,7 @@ object FirAnnotationClassDeclarationChecker : FirBasicDeclarationChecker() { } private fun isAllowedArray(typeRef: FirTypeRef, session: FirSession): Boolean { - val typeArguments = typeRef.coneTypeUnsafe().typeArguments + val typeArguments = typeRef.coneType.typeArguments if (typeArguments.size != 1) return false diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt index fbf181bfa6e..695852ac7f0 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt @@ -17,13 +17,10 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory3 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.resolve.firSymbolProvider -import org.jetbrains.kotlin.fir.types.ConeClassLikeType -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.FirTypeRef -import org.jetbrains.kotlin.fir.types.coneTypeSafe +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens +// TODO: check why coneTypeSafe is necessary at some points inside object FirExposedVisibilityChecker : FirMemberDeclarationChecker() { override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { when (declaration) { @@ -67,7 +64,7 @@ object FirExposedVisibilityChecker : FirMemberDeclarationChecker() { val classVisibility = declaration.firEffectiveVisibility(declaration.session) for (parameter in declaration.typeParameters) { for (bound in parameter.symbol.fir.bounds) { - val restricting = bound.coneTypeSafe()?.leastPermissiveDescriptor(declaration.session, classVisibility) + val restricting = bound.coneType.leastPermissiveDescriptor(declaration.session, classVisibility) if (restricting != null) { reporter.reportExposure( FirErrors.EXPOSED_TYPE_PARAMETER_BOUND, @@ -99,8 +96,8 @@ object FirExposedVisibilityChecker : FirMemberDeclarationChecker() { private fun checkFunction(declaration: FirFunction<*>, reporter: DiagnosticReporter) { val functionVisibility = (declaration as FirMemberDeclaration).firEffectiveVisibility(declaration.session) if (declaration !is FirConstructor) { - val restricting = declaration.returnTypeRef.coneTypeSafe() - ?.leastPermissiveDescriptor(declaration.session, functionVisibility) + val restricting = declaration.returnTypeRef.coneType + .leastPermissiveDescriptor(declaration.session, functionVisibility) if (restricting != null) { reporter.reportExposure( FirErrors.EXPOSED_FUNCTION_RETURN_TYPE, @@ -151,9 +148,9 @@ object FirExposedVisibilityChecker : FirMemberDeclarationChecker() { memberDeclaration: FirCallableMemberDeclaration<*>?, reporter: DiagnosticReporter ) { if (typeRef == null || memberDeclaration == null) return - val receiverParameterType = typeRef.coneTypeSafe() + val receiverParameterType = typeRef.coneType val memberVisibility = memberDeclaration.firEffectiveVisibility(memberDeclaration.session) - val restricting = receiverParameterType?.leastPermissiveDescriptor(memberDeclaration.session, memberVisibility) + val restricting = receiverParameterType.leastPermissiveDescriptor(memberDeclaration.session, memberVisibility) if (restricting != null) { reporter.reportExposure( FirErrors.EXPOSED_RECEIVER_TYPE, diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationUtils.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationUtils.kt index d427c2c94df..68266ef99f0 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationUtils.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationUtils.kt @@ -15,12 +15,12 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType -import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name private fun FirAnnotationCall.toAnnotationLookupTag(): ConeClassLikeLookupTag = - ((annotationTypeRef as FirResolvedTypeRef).type as ConeClassLikeType).lookupTag + (annotationTypeRef.coneType as ConeClassLikeType).lookupTag internal fun FirAnnotationCall.toAnnotationClassId(): ClassId = toAnnotationLookupTag().classId diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index 8ab57c2989d..2f01e02d5bd 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt @@ -488,13 +488,11 @@ class FirElementSerializer private constructor( } if (parameter.isVararg) { - val varargElementType = parameter.returnTypeRef.coneTypeSafe()?.varargElementType(session) - if (varargElementType != null) { - if (useTypeTable()) { - builder.varargElementTypeId = typeId(varargElementType) - } else { - builder.setVarargElementType(typeProto(varargElementType)) - } + val varargElementType = parameter.returnTypeRef.coneType.varargElementType(session) + if (useTypeTable()) { + builder.varargElementTypeId = typeId(varargElementType) + } else { + builder.setVarargElementType(typeProto(varargElementType)) } } @@ -544,7 +542,7 @@ class FirElementSerializer private constructor( fun typeId(type: ConeKotlinType): Int = typeTable[typeProto(type)] internal fun typeProto(typeRef: FirTypeRef): ProtoBuf.Type.Builder { - return typeProto((typeRef as FirResolvedTypeRef).type) + return typeProto(typeRef.coneType) } internal fun typeProto(type: ConeKotlinType): ProtoBuf.Type.Builder { diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmClassCodegen.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmClassCodegen.kt index f165086859d..41f16278860 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmClassCodegen.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmClassCodegen.kt @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.serialization.FirElementSerializer import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol -import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.FirTypeRef -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrField @@ -73,9 +70,9 @@ class FirJvmClassCodegen( conf: TypeApproximatorConfiguration = TypeApproximatorConfiguration.PublicDeclaration ): FirTypeRef { val approximatedType = if (toSuper) - approximator.approximateToSuperType(this.coneTypeUnsafe(), conf) + approximator.approximateToSuperType(coneType, conf) else - approximator.approximateToSubType(this.coneTypeUnsafe(), conf) + approximator.approximateToSubType(coneType, conf) return withReplacedConeType(approximatedType as? ConeKotlinType) } diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt index 17d2ed5fbd1..ceabbfe90d4 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt @@ -135,7 +135,7 @@ open class FirJvmMangleComputer( receiverTypeRef?.let { builder.appendSignature(MangleConstant.EXTENSION_RECEIVER_PREFIX) - mangleType(builder, it.coneTypeUnsafe()) + mangleType(builder, it.coneType) } valueParameters.collectForMangler(builder, MangleConstant.VALUE_PARAMETERS) { @@ -148,7 +148,7 @@ open class FirJvmMangleComputer( } if (!isCtor && !returnTypeRef.isUnit && addReturnType()) { - mangleType(builder, returnTypeRef.coneTypeUnsafe()) + mangleType(builder, returnTypeRef.coneType) } } @@ -171,7 +171,7 @@ open class FirJvmMangleComputer( } private fun mangleValueParameter(vpBuilder: StringBuilder, param: FirValueParameter) { - mangleType(vpBuilder, param.returnTypeRef.coneTypeUnsafe()) + mangleType(vpBuilder, param.returnTypeRef.coneType) if (param.isVararg) { vpBuilder.appendSignature(MangleConstant.VAR_ARG_MARK) @@ -182,7 +182,7 @@ open class FirJvmMangleComputer( tpBuilder.appendSignature(index) tpBuilder.appendSignature(MangleConstant.UPPER_BOUND_SEPARATOR) - param.bounds.map { it.coneTypeUnsafe() }.collectForMangler(tpBuilder, MangleConstant.UPPER_BOUNDS) { + param.bounds.map { it.coneType }.collectForMangler(tpBuilder, MangleConstant.UPPER_BOUNDS) { mangleType(this, it) } } @@ -262,7 +262,7 @@ open class FirJvmMangleComputer( property.receiverTypeRef?.let { builder.appendSignature(MangleConstant.EXTENSION_RECEIVER_PREFIX) - mangleType(builder, it.coneTypeUnsafe()) + mangleType(builder, it.coneType) } property.typeParameters.withIndex().toList().collectForMangler(builder, MangleConstant.TYPE_PARAMETERS) { (index, typeParameter) -> diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt index 0d0de96564f..e5725ee9a33 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt @@ -239,8 +239,8 @@ class FirJvmSerializerExtension @JvmOverloads constructor( private fun FirFunction<*>.needsInlineParameterNullCheckRequirement(): Boolean = this is FirSimpleFunction && isInline && !isSuspend && !isParamAssertionsDisabled && !Visibilities.isPrivate(visibility) && - (valueParameters.any { it.returnTypeRef.coneTypeSafe()?.isBuiltinFunctionalType(session) == true } || - receiverTypeRef?.coneTypeSafe()?.isBuiltinFunctionalType(session) == true) + (valueParameters.any { it.returnTypeRef.coneType.isBuiltinFunctionalType(session) } || + receiverTypeRef?.coneType?.isBuiltinFunctionalType(session) == true) override fun serializeProperty( property: FirProperty, 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 7dc05b6419d..78c89a8ca2e 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 @@ -100,7 +100,7 @@ fun FirClassifierSymbol<*>.toSymbol( } is FirTypeAliasSymbol -> { val typeAlias = fir - val coneClassLikeType = (typeAlias.expandedTypeRef as FirResolvedTypeRef).type as ConeClassLikeType + val coneClassLikeType = typeAlias.expandedTypeRef.coneType as ConeClassLikeType coneClassLikeType.lookupTag.toSymbol(session)!!.toSymbol(session, classifierStorage) } is FirClassSymbol -> { 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 cab193bf936..2fa1d5bfbc4 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 @@ -85,7 +85,7 @@ class Fir2IrDeclarationStorage( return irFunction.valueParameters.size == firFunction.valueParameters.size && irFunction.valueParameters.zip(firFunction.valueParameters).all { (irParameter, firParameter) -> val irType = irParameter.type - val firType = (firParameter.returnTypeRef as FirResolvedTypeRef).type + val firType = firParameter.returnTypeRef.coneType if (irType is IrSimpleType) { when (val irClassifierSymbol = irType.classifier) { is IrTypeParameterSymbol -> { @@ -741,7 +741,7 @@ class Fir2IrDeclarationStorage( startOffset, endOffset, origin, symbol, valueParameter.name, index, type, if (!valueParameter.isVararg) null - else valueParameter.returnTypeRef.coneTypeSafe()?.arrayElementType()?.toIrType(typeContext), + else valueParameter.returnTypeRef.coneType.arrayElementType()?.toIrType(typeContext), valueParameter.isCrossinline, valueParameter.isNoinline ).apply { descriptor.bind(this) 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 eee10a6e408..6951f5cadc9 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 @@ -298,7 +298,7 @@ class Fir2IrVisitor( val afterNotNullCheck = safeCallExpression.regularQualifiedAccess.accept(this, data) as IrExpression val isReceiverNullable = with(components.session.typeContext) { - safeCallExpression.receiver.typeRef.coneTypeSafe()?.isNullableType() == true + safeCallExpression.receiver.typeRef.coneType.isNullableType() } components.createSafeCallConstruction( 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 2e5e43bfd16..199ba18c094 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 @@ -29,8 +29,8 @@ fun FirComparisonExpression.inferPrimitiveNumericComparisonInfo(): PrimitiveCone inferPrimitiveNumericComparisonInfo(left, right) fun inferPrimitiveNumericComparisonInfo(left: FirExpression, right: FirExpression): PrimitiveConeNumericComparisonInfo? { - val leftType = left.typeRef.coneTypeSafe() ?: return null - val rightType = right.typeRef.coneTypeSafe() ?: return null + val leftType = left.typeRef.coneType + val rightType = right.typeRef.coneType val leftPrimitiveOrNullableType = leftType.getPrimitiveTypeOrSupertype() ?: return null val rightPrimitiveOrNullableType = rightType.getPrimitiveTypeOrSupertype() ?: return null val leastCommonType = leastCommonPrimitiveNumericType(leftPrimitiveOrNullableType, rightPrimitiveOrNullableType) @@ -62,7 +62,7 @@ private fun ConeKotlinType.getPrimitiveTypeOrSupertype(): ConeClassLikeType? = when { this is ConeTypeParameterType -> this.lookupTag.typeParameterSymbol.fir.bounds.firstNotNullResult { - it.coneTypeSafe()?.getPrimitiveTypeOrSupertype() + it.coneType.getPrimitiveTypeOrSupertype() } this is ConeClassLikeType && isPrimitiveNumberType() -> this 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 392822622f5..69dc5a01e96 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 @@ -251,7 +251,7 @@ class CallAndReferenceGenerator( } fun convertToIrConstructorCall(annotationCall: FirAnnotationCall): IrExpression { - val coneType = (annotationCall.annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeLookupTagBasedType + val coneType = annotationCall.annotationTypeRef.coneTypeSafe() val firSymbol = coneType?.lookupTag?.toSymbol(session) as? FirClassSymbol val type = coneType?.toIrType() val symbol = type?.classifierOrNull @@ -292,8 +292,7 @@ class CallAndReferenceGenerator( } internal fun convertToGetObject(qualifier: FirResolvedQualifier, callableReferenceMode: Boolean): IrExpression? { - val typeRef = qualifier.typeRef as? FirResolvedTypeRef - val classSymbol = (typeRef?.type as? ConeClassLikeType)?.lookupTag?.toSymbol(session) + val classSymbol = (qualifier.typeRef.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session) if (callableReferenceMode && classSymbol is FirRegularClassSymbol) { if (classSymbol.classId != qualifier.classId) { return null @@ -428,7 +427,7 @@ class CallAndReferenceGenerator( private fun needSamConversion(argument: FirExpression, parameter: FirValueParameter): Boolean { // If the expected type is a built-in functional type, we don't need SAM conversion. - if (parameter.returnTypeRef.coneTypeSafe()?.isBuiltinFunctionalType(session) == true) { + if (parameter.returnTypeRef.coneType.isBuiltinFunctionalType(session)) { return false } // On the other hand, the actual type should be a functional type. 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 4f2ac29e530..0fca9a585bb 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 @@ -257,7 +257,7 @@ internal class ClassMemberGenerator( val firDispatchReceiver = dispatchReceiver return convertWithOffsets { startOffset, endOffset -> val irConstructorSymbol = declarationStorage.getIrFunctionSymbol(constructorSymbol) as IrConstructorSymbol - val typeArguments = (constructedTypeRef as? FirResolvedTypeRef)?.type?.fullyExpandedType(session)?.typeArguments + val typeArguments = constructedTypeRef.coneType.fullyExpandedType(session).typeArguments val constructor = constructorSymbol.fir if (constructor.isFromEnumClass || constructor.returnTypeRef.isEnum) { IrEnumConstructorCallImpl( @@ -277,7 +277,7 @@ internal class ClassMemberGenerator( ) }.let { if (constructor.typeParameters.isNotEmpty()) { - if (typeArguments?.isNotEmpty() == true) { + if (typeArguments.isNotEmpty()) { for ((index, typeArgument) in typeArguments.withIndex()) { if (index >= constructor.typeParameters.size) break val irType = (typeArgument as ConeKotlinTypeProjection).type.toIrType() diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 79a1878bc77..b08c531bb17 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -221,7 +221,7 @@ private fun FirTypeParameter.getErasedUpperBound( ): ConeKotlinType { if (this === potentiallyRecursiveTypeParameter) return defaultValue() - val firstUpperBound = this.bounds.first().coneTypeUnsafe() + val firstUpperBound = this.bounds.first().coneType return getErasedVersionOfFirstUpperBound(firstUpperBound, mutableSetOf(this, potentiallyRecursiveTypeParameter), defaultValue) } @@ -256,7 +256,7 @@ private fun getErasedVersionOfFirstUpperBound( val current = firstUpperBound.lookupTag.typeParameterSymbol.fir if (alreadyVisitedParameters.add(current)) { - val nextUpperBound = current.bounds.first().coneTypeUnsafe() + val nextUpperBound = current.bounds.first().coneType getErasedVersionOfFirstUpperBound(nextUpperBound, alreadyVisitedParameters, defaultValue) } else { defaultValue() diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index 3677166bad9..e68ffe222cb 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -119,7 +119,7 @@ private fun coneFlexibleOrSimpleType( // TODO: we need enhancement for type parameter bounds for this code to work properly // At this moment, this condition is always true if (lookupTag.typeParameterSymbol.fir.bounds.any { - val type = (it as FirResolvedTypeRef).type + val type = it.coneType type is ConeTypeParameterType || type.isNullable } ) { diff --git a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt index 9e27e227d48..f5e0481e6fa 100644 --- a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt +++ b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt @@ -9,8 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.calls.AbstractConeCallConflictResolver import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.resolve.calls.results.FlatSignature import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator @@ -55,7 +54,7 @@ class ConeEquivalentCallConflictResolver( ): Boolean { if (first.symbol.callableId != second.symbol.callableId) return false if (first.isExpect != second.isExpect) return false - if (first.receiverTypeRef?.coneTypeUnsafe() != second.receiverTypeRef?.coneTypeUnsafe()) { + if (first.receiverTypeRef?.coneType != second.receiverTypeRef?.coneType) { return false } val firstSignature = createFlatSignature(firstCandidate, first) diff --git a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/DescriptorUtils.kt b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/DescriptorUtils.kt index d0dcb39b579..ddc21ef58a8 100644 --- a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/DescriptorUtils.kt +++ b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/DescriptorUtils.kt @@ -108,7 +108,7 @@ private fun StringBuilder.appendConeType(coneType: ConeKotlinType) { } is ConeTypeParameterType -> { val representative = coneType.lookupTag.typeParameterSymbol.fir.bounds.firstOrNull { - (it as? FirResolvedTypeRef)?.type is ConeClassLikeType + it.coneType is ConeClassLikeType } if (representative == null || representative is FirImplicitNullableAnyTypeRef || representative is FirImplicitAnyTypeRef) { append("Ljava/lang/Object") diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt index 738bf781345..4023702d636 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt @@ -418,7 +418,7 @@ class DeclarationsConverter( delegatedSuperTypeRef = buildResolvedTypeRef { type = ConeClassLikeTypeImpl( implicitEnumType.type.lookupTag, - arrayOf(selfType.coneTypeUnsafe()), + arrayOf(selfType.type), isNullable = false ) } diff --git a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index db99b0dc0cb..21acc3a9eca 100644 --- a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -490,7 +490,7 @@ class RawFirBuilder( delegatedSuperTypeRef = buildResolvedTypeRef { type = ConeClassLikeTypeImpl( implicitEnumType.type.lookupTag, - delegatedSelfTypeRef?.coneTypeUnsafe()?.let { arrayOf(it) } ?: emptyArray(), + delegatedSelfTypeRef?.coneType?.let { arrayOf(it) } ?: emptyArray(), isNullable = false, ) } 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 1eaa622c87e..e344158242d 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 @@ -132,7 +132,7 @@ class FirDoubleColonExpressionResolver( } private fun resolveExpressionOnLHS(expression: FirExpression): DoubleColonLHS.Expression? { - val type = (expression.typeRef as? FirResolvedTypeRef)?.type ?: return null + val type = expression.typeRef.coneType if (expression is FirResolvedQualifier) { val firClass = expression.expandedRegularClassIfAny() ?: return null @@ -161,9 +161,8 @@ class FirDoubleColonExpressionResolver( if (typeArgument == null) ConeStarProjection else when (typeArgument) { is FirTypeProjectionWithVariance -> { - val coneType = typeArgument.typeRef.coneTypeSafe() - if (coneType == null) ConeStarProjection - else when (typeArgument.variance) { + val coneType = typeArgument.typeRef.coneType + when (typeArgument.variance) { Variance.INVARIANT -> coneType Variance.IN_VARIANCE -> ConeKotlinTypeProjectionIn(coneType) Variance.OUT_VARIANCE -> ConeKotlinTypeProjectionOut(coneType) 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 6fca6b13e53..8944ae60605 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 @@ -217,9 +217,9 @@ fun FirFunction<*>.constructFunctionalTypeRef(isSuspend: Boolean = false): FirRe val parameters = valueParameters.map { it.returnTypeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type for parameter") } - val rawReturnType = (this as FirTypedDeclaration).returnTypeRef.coneTypeUnsafe() + val rawReturnType = (this as FirTypedDeclaration).returnTypeRef.coneType - val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneTypeSafe(), rawReturnType, isSuspend = isSuspend) + val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneType, rawReturnType, isSuspend = isSuspend) return buildResolvedTypeRef { source = this@constructFunctionalTypeRef.source?.withKind(FirFakeSourceElementKind.ImplicitTypeRef) @@ -362,13 +362,13 @@ fun BodyResolveComponents.typeFromCallee(access: T): FirReso private fun BodyResolveComponents.typeFromSymbol(symbol: AbstractFirBasedSymbol<*>, makeNullable: Boolean): FirResolvedTypeRef { return when (symbol) { is FirCallableSymbol<*> -> { - val returnType = returnTypeCalculator.tryCalculateReturnType(symbol.phasedFir) + val returnTypeRef = returnTypeCalculator.tryCalculateReturnType(symbol.phasedFir) if (makeNullable) { - returnType.withReplacedConeType( - returnType.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE, session.typeContext), + returnTypeRef.withReplacedConeType( + returnTypeRef.type.withNullability(ConeNullability.NULLABLE, session.typeContext), ) } else { - returnType + returnTypeRef } } is FirClassifierSymbol<*> -> { @@ -385,7 +385,7 @@ private fun BodyResolveComponents.typeFromSymbol(symbol: AbstractFirBasedSymbol< fun BodyResolveComponents.transformQualifiedAccessUsingSmartcastInfo(qualifiedAccessExpression: FirQualifiedAccessExpression): FirQualifiedAccessExpression { val typesFromSmartCast = dataFlowAnalyzer.getTypeUsingSmartcastInfo(qualifiedAccessExpression) ?: return qualifiedAccessExpression val allTypes = typesFromSmartCast.also { - it += qualifiedAccessExpression.resultType.coneTypeUnsafe() + it += qualifiedAccessExpression.resultType.coneType } val intersectedType = ConeTypeIntersector.intersectTypes(inferenceComponents.ctx, allTypes) // TODO: add check that intersectedType is not equal to original type @@ -463,7 +463,7 @@ private fun FirQualifiedAccess.expressionTypeOrUnitForAssignment(): ConeKotlinTy } fun FirAnnotationCall.getCorrespondingConstructorReferenceOrNull(session: FirSession): FirResolvedNamedReference? = - annotationTypeRef.coneTypeSafe()?.classId?.let { + annotationTypeRef.coneType.classId?.let { (session.firSymbolProvider.getClassLikeSymbolByFqName(it) as? FirRegularClassSymbol)?.fir ?.getPrimaryConstructorIfAny() ?.let { annotationConstructor -> diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt index 9e5ce58309e..76ae0b16904 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt @@ -148,7 +148,7 @@ class FirSamResolverImpl( newTypeParameter.bounds += declared.bounds.mapNotNull { typeRef -> buildResolvedTypeRef { source = typeRef.source - type = substitutor.substituteOrSelf(typeRef.coneTypeSafe() ?: return@mapNotNull null) + type = substitutor.substituteOrSelf(typeRef.coneType) } } } @@ -333,9 +333,7 @@ fun FirSimpleFunction.isPublicInObject(checkOnlyName: Boolean): Boolean { } private fun FirValueParameter.hasTypeOf(classId: ClassId, allowNullable: Boolean): Boolean { - val type = returnTypeRef.coneTypeSafe() ?: return false - - val classLike = when (type) { + val classLike = when (val type = returnTypeRef.coneType) { is ConeClassLikeType -> type is ConeFlexibleType -> type.upperBound as? ConeClassLikeType ?: return false else -> return false @@ -354,7 +352,7 @@ private fun FirSimpleFunction.getFunctionTypeForAbstractMethod(): ConeLookupTagB return createFunctionalType( parameterTypes, receiverType = null, - rawReturnType = returnTypeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type for return type of $this"), + rawReturnType = returnTypeRef.coneType, isSuspend = this.isSuspend ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt index 4d0bd6fd1ab..c4d97cd3f28 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt @@ -37,7 +37,7 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession) useSiteSession, FirStandardOverrideChecker(useSiteSession), fir.bounds.mapNotNullTo(mutableListOf()) { - it.coneTypeUnsafe().scope(useSiteSession, scopeSession) + it.coneType.scope(useSiteSession, scopeSession) } ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt index 98cc86560b9..8d409edee3e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt @@ -67,7 +67,7 @@ fun createSubstitution( else /* StarProjection */ -> { ConeTypeIntersector.intersectTypes( session.typeContext, - typeParameterSymbol.fir.bounds.map { it.coneTypeUnsafe() } + typeParameterSymbol.fir.bounds.map { it.coneType } ) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt index e5e9b7032d1..01ddc5d2001 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents import org.jetbrains.kotlin.fir.symbols.StandardClassIds -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.arrayElementType -import org.jetbrains.kotlin.fir.types.classId -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.resolve.calls.results.* import org.jetbrains.kotlin.types.checker.requireOrDescribe import org.jetbrains.kotlin.types.model.KotlinTypeMarker @@ -112,7 +109,7 @@ abstract class AbstractConeCallConflictResolver( return FlatSignature( call, (variable as? FirProperty)?.typeParameters?.map { it.symbol }.orEmpty(), - listOfNotNull(variable.receiverTypeRef?.coneTypeUnsafe()), + listOfNotNull(variable.receiverTypeRef?.coneType), variable.receiverTypeRef != null, false, 0, @@ -149,7 +146,7 @@ abstract class AbstractConeCallConflictResolver( } private fun FirValueParameter.argumentType(): ConeKotlinType { - val type = returnTypeRef.coneTypeUnsafe() + val type = returnTypeRef.coneType if (isVararg) return type.arrayElementType()!! return type } @@ -158,7 +155,7 @@ abstract class AbstractConeCallConflictResolver( call: Candidate, function: FirFunction<*> ): List { - return listOfNotNull(function.receiverTypeRef?.coneTypeUnsafe()) + + return listOfNotNull(function.receiverTypeRef?.coneType) + (call.resultingTypeForCallableReference?.typeArguments?.map { it as ConeKotlinType } ?: call.argumentMapping?.map { it.value.argumentType() }.orEmpty()) } 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 809014d79ac..c3e6ac33038 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 @@ -132,7 +132,7 @@ private fun Candidate.resolveBlockArgument( if (returnArguments.isEmpty()) { checkApplicabilityForArgumentType( csBuilder, - block.typeRef.coneTypeUnsafe(), + block.typeRef.coneType, expectedType?.type, SimpleConstraintSystemConstraintPosition, isReceiver = false, @@ -177,9 +177,9 @@ fun Candidate.resolveSubCallArgument( * placeholder type with value 0, but argument contains type with proper literal value */ val type: ConeKotlinType = if (candidate.symbol.fir is FirIntegerOperator) { - (argument as FirFunctionCall).resultType.coneTypeUnsafe() + (argument as FirFunctionCall).resultType.coneType } else { - sink.components.returnTypeCalculator.tryCalculateReturnType(candidate.symbol.firUnsafe()).coneTypeUnsafe() + sink.components.returnTypeCalculator.tryCalculateReturnType(candidate.symbol.firUnsafe()).type } val argumentType = candidate.substitutor.substituteOrSelf(type) resolvePlainArgumentType(csBuilder, argumentType, expectedType, sink, isReceiver, isDispatch, useNullableArgumentType) @@ -308,7 +308,7 @@ internal fun Candidate.resolveArgument( private fun Candidate.prepareExpectedType(session: FirSession, argument: FirExpression, parameter: FirValueParameter?): ConeKotlinType? { if (parameter == null) return null - if (parameter.returnTypeRef is FirILTTypeRefPlaceHolder) return argument.resultType.coneTypeUnsafe() + if (parameter.returnTypeRef is FirILTTypeRefPlaceHolder) return argument.resultType.coneType val basicExpectedType = argument.getExpectedType(session, parameter/*, LanguageVersionSettings*/) val expectedType = getExpectedTypeWithSAMConversion(session, argument, basicExpectedType) ?: basicExpectedType return this.substitutor.substituteOrSelf(expectedType) @@ -350,9 +350,9 @@ internal fun FirExpression.getExpectedType( } return if (parameter.isVararg && shouldUnwrapVarargType) { - parameter.returnTypeRef.coneTypeUnsafe().varargElementType(session) + parameter.returnTypeRef.coneType.varargElementType(session) } else { - parameter.returnTypeRef.coneTypeUnsafe() + parameter.returnTypeRef.coneType } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt index ecb89da25f8..70ed26c8ad7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents import org.jetbrains.kotlin.fir.resolve.inference.TypeParameterBasedTypeVariable import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition import org.jetbrains.kotlin.resolve.calls.results.FlatSignature @@ -192,7 +192,7 @@ class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl) : Simp for (upperBound in typeParameter.fir.bounds) { addSubtypeConstraint( substitutionMap[typeParameter] ?: error("No ${typeParameter.fir.render()} in substitution map"), - substitutor.substituteOrSelf(upperBound.coneTypeUnsafe()) + substitutor.substituteOrSelf(upperBound.coneType) ) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt index c84fdedabb3..78b99f1d4e2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.name.Name private operator fun Pair?.component1() = this?.first @@ -215,10 +216,10 @@ private class TypeAliasConstructorsSubstitutor>( ) { fun substitute(baseFunction: F): F { val typeParameters = typeAliasSymbol.fir.typeParameters - val newReturnType = baseFunction.returnTypeRef.coneTypeUnsafe().let(substitutor::substituteOrNull) + val newReturnType = baseFunction.returnTypeRef.coneType.let(substitutor::substituteOrNull) val newParameterTypes = baseFunction.valueParameters.map { valueParameter -> - valueParameter.returnTypeRef.coneTypeUnsafe().let(substitutor::substituteOrNull) + valueParameter.returnTypeRef.coneType.let(substitutor::substituteOrNull) } if (newReturnType == null && newParameterTypes.all { it == null }) return baseFunction diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt index 5625d4061b4..9054281d892 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt @@ -64,7 +64,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() { is FirTypeProjectionWithVariance -> csBuilder.addEqualityConstraint( freshVariable.defaultType, getTypePreservingFlexibilityWrtTypeVariable( - typeArgument.typeRef.coneTypeUnsafe(), + typeArgument.typeRef.coneType, typeParameter, candidate.bodyResolveComponents.inferenceComponents.ctx ), @@ -72,7 +72,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() { ) is FirStarProjection -> csBuilder.addEqualityConstraint( freshVariable.defaultType, - typeParameter.symbol.fir.bounds.firstOrNull()?.coneTypeUnsafe() + typeParameter.symbol.fir.bounds.firstOrNull()?.coneType ?: sink.components.session.builtinTypes.nullableAnyType.type, SimpleConstraintSystemConstraintPosition ) @@ -98,7 +98,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() { private fun FirTypeParameterRef.shouldBeFlexible(context: ConeTypeContext): Boolean { return symbol.fir.bounds.any { - val type = it.coneTypeUnsafe() + val type = it.coneType type is ConeFlexibleType || with(context) { (type.typeConstructor() as? FirTypeParameterSymbol)?.fir?.shouldBeFlexible(context) ?: false } @@ -147,7 +147,7 @@ private fun createToFreshVariableSubstitutorAndAddInitialConstraints( //val position = DeclaredUpperBoundConstraintPosition(typeParameter) for (upperBound in typeParameter.symbol.fir.bounds) { - freshVariable.addSubtypeConstraint(upperBound.coneTypeUnsafe()/*, position*/) + freshVariable.addSubtypeConstraint(upperBound.coneType/*, position*/) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt index 45defe91119..aeb6376ccc6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt @@ -41,6 +41,7 @@ abstract class AbstractExplicitReceiver : Receiver { abstract class AbstractExplicitReceiverValue : AbstractExplicitReceiver(), ReceiverValue { override val type: ConeKotlinType + // NB: safe cast is necessary here get() = explicitReceiver.typeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type calculated for: ${explicitReceiver.renderWithType()}") // TODO: assert here @@ -75,7 +76,7 @@ sealed class ImplicitReceiverValue>( internal fun replaceType(type: ConeKotlinType) { if (type == this.type) return this.type = type - receiverExpression = if (type == originalReceiverExpression.typeRef.coneTypeUnsafe()) { + receiverExpression = if (type == originalReceiverExpression.typeRef.coneType) { originalReceiverExpression } else { buildExpressionWithSmartcast { 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 7b8758ae026..6a1ef369b36 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 @@ -94,7 +94,7 @@ internal sealed class CheckReceivers : ResolutionStage() { override fun Candidate.getReceiverType(): ConeKotlinType? { val callableSymbol = symbol as? FirCallableSymbol<*> ?: return null val callable = callableSymbol.fir - val receiverType = callable.receiverTypeRef?.coneTypeUnsafe() + val receiverType = callable.receiverTypeRef?.coneType if (receiverType != null) return receiverType val returnTypeRef = callable.returnTypeRef as? FirResolvedTypeRef ?: return null if (!returnTypeRef.type.isExtensionFunctionType(bodyResolveComponents.session)) return null @@ -244,7 +244,7 @@ internal object CheckCallableReferenceExpectedType : CheckerStage() { } val declarationReceiverType: ConeKotlinType? = - (fir as? FirCallableMemberDeclaration<*>)?.receiverTypeRef?.coneTypeSafe() + (fir as? FirCallableMemberDeclaration<*>)?.receiverTypeRef?.coneType ?.let(candidate.substitutor::substituteOrSelf) if (resultingReceiverType != null && declarationReceiverType != null) { @@ -273,7 +273,7 @@ private fun createKPropertyType( receiverType: ConeKotlinType?, returnTypeRef: FirResolvedTypeRef ): ConeKotlinType { - val propertyType = returnTypeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type for of $propertyOrField") + val propertyType = returnTypeRef.type return createKPropertyType( receiverType, propertyType, isMutable = propertyOrField.isVar ) @@ -296,8 +296,7 @@ private fun FirSession.createKFunctionType( } for ((index, valueParameter) in function.valueParameters.withIndex()) { if (expectedParameterNumber == null || index < expectedParameterNumber || valueParameter.defaultValue == null) { - parameterTypes += valueParameter.returnTypeRef.coneTypeSafe() - ?: ConeKotlinErrorType("No type for parameter $valueParameter") + parameterTypes += valueParameter.returnTypeRef.coneType } } @@ -305,7 +304,7 @@ private fun FirSession.createKFunctionType( if (expectedReturnType != null && typeContext.run { expectedReturnType.isUnit() }) expectedReturnType else - returnTypeRef.coneTypeSafe() ?: ConeKotlinErrorType("No type for return type of $function") + returnTypeRef.type return createFunctionalType( parameterTypes, receiverType = receiverType, @@ -532,7 +531,7 @@ internal object PostponedVariablesInitializerResolutionStage : ResolutionStage() if (candidate.typeArgumentMapping is TypeArgumentMapping.Mapped) return for (parameter in argumentMapping.values) { if (!parameter.hasBuilderInferenceMarker()) continue - val type = parameter.returnTypeRef.coneTypeSafe() ?: continue + val type = parameter.returnTypeRef.coneType val receiverType = type.receiverType(callInfo.session) ?: continue for (freshVariable in candidate.freshVariables) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt index fd474556a57..cde2bc86049 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt @@ -201,9 +201,7 @@ private class TowerScopeLevelProcessor( val extensionReceiverType = explicitReceiver?.typeRef?.coneTypeSafe() ?: implicitExtensionReceiverValue?.type as? ConeClassLikeType if (extensionReceiverType != null) { - val declarationReceiverTypeRef = - (symbol as? FirCallableSymbol<*>)?.fir?.receiverTypeRef as? FirResolvedTypeRef - val declarationReceiverType = declarationReceiverTypeRef?.type + val declarationReceiverType = (symbol as? FirCallableSymbol<*>)?.fir?.receiverTypeRef?.coneType if (declarationReceiverType is ConeClassLikeType) { if (!AbstractTypeChecker.isSubtypeOf( candidateFactory.bodyResolveComponents.inferenceComponents.ctx, 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 a95a4a0ca37..8637800628e 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 @@ -103,8 +103,8 @@ abstract class FirDataFlowAnalyzer( private var contractDescriptionVisitingMode = false - protected val any = components.session.builtinTypes.anyType.coneTypeUnsafe() - private val nullableNothing = components.session.builtinTypes.nullableNothingType.coneTypeUnsafe() + protected val any = components.session.builtinTypes.anyType.type + private val nullableNothing = components.session.builtinTypes.nullableNothingType.type // ----------------------------------- Requests ----------------------------------- @@ -263,7 +263,7 @@ abstract class FirDataFlowAnalyzer( fun exitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) { val node = graphBuilder.exitTypeOperatorCall(typeOperatorCall).mergeIncomingFlow() if (typeOperatorCall.operation !in FirOperation.TYPES) return - val type = typeOperatorCall.conversionTypeRef.coneTypeUnsafe() + val type = typeOperatorCall.conversionTypeRef.coneType val operandVariable = variableStorage.getOrCreateVariable(node.previousFlow, typeOperatorCall.argument) val flow = node.flow @@ -388,8 +388,8 @@ abstract class FirDataFlowAnalyzer( } private fun processEq(node: OperatorCallNode, leftOperand: FirExpression, rightOperand: FirExpression, operation: FirOperation) { - val leftIsNullable = leftOperand.coneType?.isMarkedNullable ?: return - val rightIsNullable = rightOperand.coneType?.isMarkedNullable ?: return + val leftIsNullable = leftOperand.coneType.isMarkedNullable + val rightIsNullable = rightOperand.coneType.isMarkedNullable // left == right && right not null -> left != null when { leftIsNullable && rightIsNullable -> return @@ -638,8 +638,7 @@ abstract class FirDataFlowAnalyzer( } safeCall.receiver.let { receiver -> - val type = receiver.coneType - ?.takeIf { it.isMarkedNullable } + val type = receiver.coneType.takeIf { it.isMarkedNullable } ?.withNullability(ConeNullability.NOT_NULL) ?: return@let @@ -837,7 +836,7 @@ abstract class FirDataFlowAnalyzer( if (isAssignment) { if (initializer is FirConstExpression<*> && initializer.kind == FirConstKind.Null) return - flow.addTypeStatement(propertyVariable typeEq initializer.typeRef.coneTypeUnsafe()) + flow.addTypeStatement(propertyVariable typeEq initializer.typeRef.coneType) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/util.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/util.kt index add4db2ed34..81c725e8825 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/util.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/util.kt @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.coneTypeSafe +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.utils.addToStdlib.safeAs import kotlin.contracts.ExperimentalContracts import kotlin.contracts.InvocationKind @@ -88,8 +88,8 @@ internal fun ConeConstantReference.toOperation(): Operation = when (this) { } @DfaInternals -internal val FirExpression.coneType: ConeKotlinType? - get() = typeRef.coneTypeSafe() +internal val FirExpression.coneType: ConeKotlinType + get() = typeRef.coneType @DfaInternals internal val FirElement.symbol: AbstractFirBasedSymbol<*>? 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 dfad22ba1b8..547ed04ccd7 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 @@ -19,10 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.ConeTypeVariableTypeConstructor -import org.jetbrains.kotlin.fir.types.coneTypeSafe -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder import org.jetbrains.kotlin.resolve.calls.inference.NewConstraintSystem import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor @@ -49,7 +46,7 @@ class FirDelegatedPropertyInferenceSession( } val expectedType: ConeKotlinType? by lazy { property.returnTypeRef.coneTypeSafe() } - private val unitType: ConeKotlinType = components.session.builtinTypes.unitType.coneTypeUnsafe() + private val unitType: ConeKotlinType = components.session.builtinTypes.unitType.type private lateinit var resultingConstraintSystem: NewConstraintSystem override fun shouldRunCompletion(call: T): Boolean where T : FirResolvable, T : FirStatement = false @@ -106,7 +103,7 @@ class FirDelegatedPropertyInferenceSession( private fun Candidate.addConstraintsForGetValueMethod(commonSystem: ConstraintSystemBuilder) { if (expectedType != null) { val accessor = symbol.fir as? FirSimpleFunction ?: return - val unsubstitutedReturnType = accessor.returnTypeRef.coneTypeSafe() ?: return + val unsubstitutedReturnType = accessor.returnTypeRef.coneType val substitutedReturnType = substitutor.substituteOrSelf(unsubstitutedReturnType) commonSystem.addSubtypeConstraint(substitutedReturnType, expectedType!!, SimpleConstraintSystemConstraintPosition) @@ -118,7 +115,7 @@ class FirDelegatedPropertyInferenceSession( private fun Candidate.addConstraintsForSetValueMethod(commonSystem: ConstraintSystemBuilder) { if (expectedType != null) { val accessor = symbol.fir as? FirSimpleFunction ?: return - val unsubstitutedParameterType = accessor.valueParameters.getOrNull(2)?.returnTypeRef?.coneTypeSafe() ?: return + val unsubstitutedParameterType = accessor.valueParameters.getOrNull(2)?.returnTypeRef?.coneType ?: return val substitutedReturnType = substitutor.substituteOrSelf(unsubstitutedParameterType) commonSystem.addSubtypeConstraint(substitutedReturnType, expectedType!!, SimpleConstraintSystemConstraintPosition) @@ -128,14 +125,14 @@ class FirDelegatedPropertyInferenceSession( } private fun Candidate.addConstraintForThis(commonSystem: ConstraintSystemBuilder) { - val typeOfThis: ConeKotlinType = property.receiverTypeRef?.coneTypeUnsafe() + val typeOfThis: ConeKotlinType = property.receiverTypeRef?.coneType ?: when (val container = components.container) { is FirRegularClass -> container.defaultType() is FirAnonymousObject -> container.defaultType() else -> null - } ?: components.session.builtinTypes.nullableNothingType.coneTypeUnsafe() + } ?: components.session.builtinTypes.nullableNothingType.type val valueParameterForThis = (symbol as? FirFunctionSymbol<*>)?.fir?.valueParameters?.firstOrNull() ?: return - val substitutedType = substitutor.substituteOrSelf(valueParameterForThis.returnTypeRef.coneTypeUnsafe()) + val substitutedType = substitutor.substituteOrSelf(valueParameterForThis.returnTypeRef.coneType) commonSystem.addSubtypeConstraint(typeOfThis, substitutedType, SimpleConstraintSystemConstraintPosition) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt index f4a6bcf0189..3402b0d61c1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt @@ -89,9 +89,9 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver { private fun createFunctionalType(typeRef: FirFunctionTypeRef): ConeClassLikeType { val parameters = - listOfNotNull((typeRef.receiverTypeRef as FirResolvedTypeRef?)?.type) + - typeRef.valueParameters.map { it.returnTypeRef.coneTypeUnsafe() } + - listOf(typeRef.returnTypeRef.coneTypeUnsafe()) + listOfNotNull(typeRef.receiverTypeRef?.coneType) + + typeRef.valueParameters.map { it.returnTypeRef.coneType } + + listOf(typeRef.returnTypeRef.coneType) val classId = if (typeRef.isSuspend) { KotlinBuiltIns.getSuspendFunctionClassId(typeRef.parametersCount) } else { 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 b08e522cf90..c0c75decac6 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 @@ -282,7 +282,7 @@ class FirCallCompletionResultsWriterTransformer( qualifiedAccessExpression: FirQualifiedAccessExpression, data: Nothing? ): CompositeTransformResult { - val originalType = qualifiedAccessExpression.typeRef.coneTypeUnsafe() + val originalType = qualifiedAccessExpression.typeRef.coneType val substitutedReceiverType = finalSubstitutor.substituteOrNull(originalType) ?: return qualifiedAccessExpression.compose() qualifiedAccessExpression.replaceTypeRef( qualifiedAccessExpression.typeRef.resolvedTypeFromPrototype(substitutedReceiverType) @@ -292,8 +292,7 @@ class FirCallCompletionResultsWriterTransformer( } private fun FirTypeRef.substitute(candidate: Candidate): ConeKotlinType = - coneTypeUnsafe() - .let { candidate.substitutor.substituteOrSelf(it) } + coneType.let { candidate.substitutor.substituteOrSelf(it) } .let { finalSubstitutor.substituteOrSelf(it) } private fun Candidate.createArgumentsMapping(): ExpectedArgumentType? { @@ -532,7 +531,7 @@ class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSu } override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult { - return finalSubstitutor.substituteOrNull(typeRef.coneTypeUnsafe())?.let { + return finalSubstitutor.substituteOrNull(typeRef.coneType)?.let { typeRef.resolvedTypeFromPrototype(it) }?.compose() ?: typeRef.compose() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt index 9e65af5e298..0e7b117940e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt @@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType -import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor import org.jetbrains.kotlin.fir.visitors.FirTransformer @@ -86,7 +86,7 @@ class FirSealedClassInheritorsTransformer : FirTransformer() { } private fun extractClassFromTypeRef(symbolProvider: FirSymbolProvider, typeRef: FirTypeRef): FirRegularClass? { - val lookupTag = ((typeRef as FirResolvedTypeRef).type as? ConeLookupTagBasedType)?.lookupTag ?: return null + val lookupTag = (typeRef.coneType as? ConeLookupTagBasedType)?.lookupTag ?: return null val classLikeSymbol: FirClassifierSymbol<*> = symbolProvider.getSymbolByLookupTag(lookupTag) ?: return null return when (classLikeSymbol) { is FirRegularClassSymbol -> classLikeSymbol.fir diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 0d664319e07..b409a9a8225 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt @@ -197,8 +197,7 @@ private class FirSupertypeResolverVisitor( ) { if (!visited.add(classLikeDeclaration)) return val supertypes = - resolveSpecificClassLikeSupertypes(classLikeDeclaration, supertypeRefs) - .mapNotNull { (it as? FirResolvedTypeRef)?.type } + resolveSpecificClassLikeSupertypes(classLikeDeclaration, supertypeRefs).map { it.coneType } for (supertype in supertypes) { if (supertype !is ConeClassLikeType) continue diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index f2695bdab72..bc706467952 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt @@ -185,7 +185,7 @@ class FirSyntheticCallGenerator( val (typeParameter, returnType) = generateSyntheticSelectTypeParameter() - val argumentType = buildResolvedTypeRef { type = returnType.coneTypeUnsafe().createArrayOf() } + val argumentType = buildResolvedTypeRef { type = returnType.type.createArrayOf() } val typeArgument = buildTypeProjectionWithVariance { typeRef = returnType variance = Variance.INVARIANT @@ -208,7 +208,7 @@ class FirSyntheticCallGenerator( val (typeParameter, returnType) = generateSyntheticSelectTypeParameter() val argumentType = buildResolvedTypeRef { - type = returnType.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE, session.typeContext) + type = returnType.type.withNullability(ConeNullability.NULLABLE, session.typeContext) } val typeArgument = buildTypeProjectionWithVariance { typeRef = returnType 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 b4892ac80cd..d7f6c308f28 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 @@ -48,7 +48,7 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe ?: return null // TODO: add some report logic about flexible type (see WHEN_ENUM_CAN_BE_NULL_IN_JAVA diagnostic in old frontend) - val type = typeRef.coneTypeSafe()?.lowerBoundIfFlexible() ?: return null + val type = typeRef.coneType.lowerBoundIfFlexible() val lookupTag = (type as? ConeLookupTagBasedType)?.lookupTag ?: return null val nullable = type.nullability == ConeNullability.NULLABLE val isExhaustive = when { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt index 2b43b5137a2..60b7c1bdd1a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt @@ -113,8 +113,8 @@ class IntegerLiteralTypeApproximationTransformer( val expectedType: ConeKotlinType? = when { !leftIsIlt && !rightIsIlt -> return operatorCall.compose() leftIsIlt && rightIsIlt -> null - leftIsIlt -> rightArgument.typeRef.coneTypeUnsafe() - rightIsIlt -> leftArgument.typeRef.coneTypeUnsafe() + leftIsIlt -> rightArgument.typeRef.coneType + rightIsIlt -> leftArgument.typeRef.coneType else -> throw IllegalStateException() } @@ -160,7 +160,7 @@ class IntegerOperatorsTypeUpdater(private val approximator: IntegerLiteralTypeAp val function: FirCallableDeclaration<*> = functionCall.getOriginalFunction() ?: return functionCall.compose() if (function !is FirIntegerOperator) { - val expectedType = function.receiverTypeRef?.coneTypeSafe() + val expectedType = function.receiverTypeRef?.coneType return functionCall.transformExplicitReceiver(approximator, expectedType).compose() } // TODO: maybe unsafe? @@ -176,7 +176,7 @@ class IntegerOperatorsTypeUpdater(private val approximator: IntegerLiteralTypeAp } else -> { // TODO: handle overflow - when (val argumentType = functionCall.argument.typeRef.coneTypeUnsafe()) { + when (val argumentType = functionCall.argument.typeRef.coneType) { is ConeIntegerLiteralType -> { val argumentValue = argumentType.value val divisionByZero = argumentValue == 0L diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt index 7151c9a40e0..3e77e25c487 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt @@ -97,7 +97,7 @@ internal fun FirValueParameter.transformVarargTypeToArrayType() { } internal fun FirTypedDeclaration.transformTypeToArrayType() { - val returnType = returnTypeRef.coneTypeUnsafe() + val returnType = returnTypeRef.coneType transformReturnTypeRef( StoreType, returnTypeRef.withReplacedConeType( 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 b98dd492ea3..29a81a42211 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 @@ -158,7 +158,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor val typeRef = propertyReferenceAccess.typeRef if (typeRef is FirResolvedTypeRef && property.returnTypeRef is FirResolvedTypeRef) { val typeArguments = (typeRef.type as ConeClassLikeType).typeArguments - val extensionType = property.receiverTypeRef?.coneTypeSafe() + val extensionType = property.receiverTypeRef?.coneType val dispatchType = containingClass?.let { containingClass -> containingClass.symbol.constructStarProjectedType(containingClass.typeParameters.size) } @@ -169,7 +169,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor type = (typeRef.type as ConeClassLikeType).lookupTag.constructClassType( typeArguments.mapIndexed { index, argument -> when (index) { - typeArguments.lastIndex -> property.returnTypeRef.coneTypeUnsafe() + typeArguments.lastIndex -> property.returnTypeRef.coneType 0 -> extensionType ?: dispatchType else -> dispatchType } ?: argument @@ -312,7 +312,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor val receiverTypeRef = owner.receiverTypeRef if (receiverTypeRef != null) { - withLabelAndReceiverType(owner.name, owner, receiverTypeRef.coneTypeUnsafe()) { + withLabelAndReceiverType(owner.name, owner, receiverTypeRef.coneType) { transformFunctionWithGivenSignature(accessor, resolutionMode) } } else { @@ -459,7 +459,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor withFullBodyResolve { val receiverTypeRef = simpleFunction.receiverTypeRef if (receiverTypeRef != null) { - withLabelAndReceiverType(simpleFunction.name, simpleFunction, receiverTypeRef.coneTypeUnsafe()) { + withLabelAndReceiverType(simpleFunction.name, simpleFunction, receiverTypeRef.coneType) { transformFunctionWithGivenSignature(simpleFunction, ResolutionMode.ContextIndependent) } } else { @@ -549,7 +549,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor dataFlowAnalyzer.enterValueParameter(valueParameter) val transformedValueParameter = - valueParameter.transformInitializer(integerLiteralTypeApproximator, valueParameter.returnTypeRef.coneTypeSafe()) + valueParameter.transformInitializer(integerLiteralTypeApproximator, valueParameter.returnTypeRef.coneType) val result = transformDeclarationContent( transformedValueParameter, @@ -641,7 +641,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null) val bodyExpectedType = returnTypeRefFromResolvedAtom ?: expectedTypeRef val labelName = af.label?.name?.let { Name.identifier(it) } - withLabelAndReceiverType(labelName, af, af.receiverTypeRef?.coneTypeSafe()) { + withLabelAndReceiverType(labelName, af, af.receiverTypeRef?.coneType) { af = transformFunction(af, withExpectedType(bodyExpectedType)).single as FirAnonymousFunction } // To separate function and separate commit @@ -655,7 +655,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor ) af.transformSingle(writer, expectedTypeRef.coneTypeSafe()?.toExpectedType()) val returnTypes = dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(af) - .mapNotNull { (it as? FirExpression)?.resultType?.coneTypeUnsafe() } + .mapNotNull { (it as? FirExpression)?.resultType?.coneType } af.replaceReturnTypeRef( af.returnTypeRef.resolvedTypeFromPrototype( inferenceComponents.ctx.commonSuperTypeOrNull(returnTypes) ?: session.builtinTypes.unitType.type 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 5d8f90c1bc0..98f367bb309 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 @@ -411,7 +411,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform FirOperation.SAFE_AS -> { resolved.resultType = conversionTypeRef.withReplacedConeType( - conversionTypeRef.coneTypeUnsafe().withNullability( + conversionTypeRef.coneType.withNullability( ConeNullability.NULLABLE, session.typeContext, ), ) @@ -550,7 +550,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform lhs.replaceTypeRef(buildResolvedTypeRef { type = typeRef }) typeRef } else { - lhs.resultType.coneTypeUnsafe() + lhs.resultType.coneType } } is FirResolvedReifiedParameterReference -> { @@ -558,7 +558,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform symbol.constructType(emptyArray(), isNullable = false) } else -> { - lhs.resultType.coneTypeUnsafe() + lhs.resultType.coneType } } 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 14348c5f585..b8f2beb88f5 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 @@ -13,8 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.coneTypeSafe -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor class ConeEffectExtractor( @@ -116,7 +115,7 @@ class ConeEffectExtractor( val symbol = qualifiedAccessExpression.toResolvedCallableSymbol() ?: return null val parameter = symbol.fir as? FirValueParameter ?: return null val index = valueParameters.indexOf(parameter).takeUnless { it < 0 } ?: return null - val type = parameter.returnTypeRef.coneTypeUnsafe() + val type = parameter.returnTypeRef.coneType val name = parameter.name.asString() return toValueParameterReference(type, index, name) @@ -140,7 +139,7 @@ class ConeEffectExtractor( ): ConeContractDescriptionElement? { val declaration = thisReceiverExpression.calleeReference.boundSymbol?.fir ?: return null return if (declaration == owner) { - val type = thisReceiverExpression.typeRef.coneTypeSafe() ?: return null + val type = thisReceiverExpression.typeRef.coneType toValueParameterReference(type, -1, "this") } else { null @@ -160,7 +159,7 @@ class ConeEffectExtractor( override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Nothing?): ConeContractDescriptionElement? { val arg = typeOperatorCall.argument.accept(this, data) as? ConeValueParameterReference ?: return null - val type = typeOperatorCall.conversionTypeRef.coneTypeSafe() ?: return null + val type = typeOperatorCall.conversionTypeRef.coneType val isNegated = typeOperatorCall.operation == FirOperation.NOT_IS return ConeIsInstancePredicate(arg, type, isNegated) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt index ea2b15aa2ca..f763ba98c43 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeContractDescriptionError import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.fir.visitors.transformSingle @@ -59,7 +59,7 @@ class FirContractResolveTransformer( return withTypeParametersOf(simpleFunction) { val receiverTypeRef = simpleFunction.receiverTypeRef if (receiverTypeRef != null) { - withLabelAndReceiverType(simpleFunction.name, simpleFunction, receiverTypeRef.coneTypeUnsafe()) { + withLabelAndReceiverType(simpleFunction.name, simpleFunction, receiverTypeRef.coneType) { transformContractDescriptionOwner(simpleFunction) } } else { @@ -101,7 +101,7 @@ class FirContractResolveTransformer( } val receiverTypeRef = owner.receiverTypeRef return if (receiverTypeRef != null) { - withLabelAndReceiverType(owner.name, propertyAccessor, receiverTypeRef.coneTypeUnsafe()) { + withLabelAndReceiverType(owner.name, propertyAccessor, receiverTypeRef.coneType) { transformContractDescriptionOwner(propertyAccessor) } } else { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 67270703028..1119c47e919 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt @@ -26,11 +26,8 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.impl.* -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef -import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.withKind import org.jetbrains.kotlin.name.ClassId @@ -125,7 +122,7 @@ class FirClassSubstitutionScope( val (newTypeParameters, newReceiverType, newReturnType, newSubstitutor) = createSubstitutedData(member) val newParameterTypes = member.valueParameters.map { - it.returnTypeRef.coneTypeUnsafe().substitute(newSubstitutor) + it.returnTypeRef.coneType.substitute(newSubstitutor) } if (newReceiverType == null && newReturnType == null && newParameterTypes.all { it == null } && @@ -157,7 +154,7 @@ class FirClassSubstitutionScope( val (newTypeParameters, _, newReturnType, newSubstitutor) = createSubstitutedData(constructor) val newParameterTypes = constructor.valueParameters.map { - it.returnTypeRef.coneTypeUnsafe().substitute(newSubstitutor) + it.returnTypeRef.coneType.substitute(newSubstitutor) } if (newReturnType == null && newParameterTypes.all { it == null } && newTypeParameters === constructor.typeParameters) { @@ -206,7 +203,7 @@ class FirClassSubstitutionScope( member as FirTypeParameterRefsOwner ) - val receiverType = member.receiverTypeRef?.coneTypeUnsafe() + val receiverType = member.receiverTypeRef?.coneType val newReceiverType = receiverType?.substitute(substitutor) val returnType = typeCalculator.tryCalculateReturnType(member).type @@ -245,7 +242,7 @@ class FirClassSubstitutionScope( if (newTypeParameter == null) continue val original = oldTypeParameter as FirTypeParameter for (boundTypeRef in original.bounds) { - val typeForBound = boundTypeRef.coneTypeUnsafe() + val typeForBound = boundTypeRef.coneType val substitutedBound = typeForBound.substitute() newTypeParameter.bounds += buildResolvedTypeRef { @@ -286,7 +283,7 @@ class FirClassSubstitutionScope( val newReturnType = returnType.substitute() val newParameterTypes = member.getter.valueParameters.map { - it.returnTypeRef.coneTypeUnsafe().substitute() + it.returnTypeRef.coneType.substitute() } if (newReturnType == null && newParameterTypes.all { it == null }) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt index e82062ab9fc..dd0d3a7a641 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt @@ -47,7 +47,7 @@ class FirStandardOverrideChecker(session: FirSession) : FirAbstractOverrideCheck } override fun isEqualTypes(candidateTypeRef: FirTypeRef, baseTypeRef: FirTypeRef, substitutor: ConeSubstitutor) = - isEqualTypes((candidateTypeRef as FirResolvedTypeRef).type, (baseTypeRef as FirResolvedTypeRef).type, substitutor) + isEqualTypes(candidateTypeRef.coneType, baseTypeRef.coneType, substitutor) /** @@ -61,13 +61,13 @@ class FirStandardOverrideChecker(session: FirSession) : FirAbstractOverrideCheck baseTypeParameter: FirTypeParameter, substitutor: ConeSubstitutor ): Boolean { - val substitutedOverrideType = substitutor.substituteOrSelf(overrideBound.coneTypeUnsafe()) - val substitutedBaseType = substitutor.substituteOrSelf(baseBound.coneTypeUnsafe()) + val substitutedOverrideType = substitutor.substituteOrSelf(overrideBound.coneType) + val substitutedBaseType = substitutor.substituteOrSelf(baseBound.coneType) if (isEqualTypes(substitutedOverrideType, substitutedBaseType)) return true - return overrideTypeParameter.bounds.any { bound -> isEqualTypes(bound.coneTypeUnsafe(), substitutedBaseType, substitutor) } && - baseTypeParameter.bounds.any { bound -> isEqualTypes(bound.coneTypeUnsafe(), substitutedOverrideType, substitutor) } + return overrideTypeParameter.bounds.any { bound -> isEqualTypes(bound.coneType, substitutedBaseType, substitutor) } && + baseTypeParameter.bounds.any { bound -> isEqualTypes(bound.coneType, substitutedOverrideType, substitutor) } } private fun isCompatibleTypeParameters( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt index 5b6d74b79d6..c19a50c7008 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt @@ -16,10 +16,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.FirTypeScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.impl.* -import org.jetbrains.kotlin.fir.types.ConeFlexibleType -import org.jetbrains.kotlin.fir.types.ConeKotlinType -import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext -import org.jetbrains.kotlin.fir.types.coneTypeSafe +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext @@ -142,7 +139,7 @@ class FirTypeIntersectionScope private constructor( if (aFir !is FirCallableMemberDeclaration<*> || bFir !is FirCallableMemberDeclaration<*>) return false val substitutor = buildSubstitutorForOverridesCheck(aFir, bFir) ?: return false - + // NB: these lines throw CCE in modularized tests when changed to just .coneType (FirImplicitTypeRef) val aReturnType = a.fir.returnTypeRef.coneTypeSafe()?.let(substitutor::substituteOrSelf) ?: return false val bReturnType = b.fir.returnTypeRef.coneTypeSafe() ?: return false diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index 37030e1d743..d632e689781 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -228,7 +228,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty //require(this is ConeSymbol) return when (this) { is ConeTypeVariableTypeConstructor -> emptyList() - is FirTypeParameterSymbol -> fir.bounds.map { it.coneTypeUnsafe() } + is FirTypeParameterSymbol -> fir.bounds.map { it.coneType } is FirClassSymbol<*> -> fir.superConeTypes is FirTypeAliasSymbol -> listOfNotNull(fir.expandedConeType) is ConeCapturedTypeConstructor -> supertypes!! @@ -259,7 +259,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty override fun TypeParameterMarker.getUpperBound(index: Int): KotlinTypeMarker { require(this is FirTypeParameterSymbol) - return this.fir.bounds[index].coneTypeUnsafe() + return this.fir.bounds[index].coneType } override fun TypeParameterMarker.getTypeConstructor(): TypeConstructorMarker { @@ -477,7 +477,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty override fun TypeParameterMarker.getRepresentativeUpperBound(): KotlinTypeMarker { require(this is FirTypeParameterSymbol) - return this.fir.bounds.getOrNull(0)?.let { (it as? FirResolvedTypeRef)?.type } + return this.fir.bounds.getOrNull(0)?.let { it.coneType } ?: session.builtinTypes.nullableAnyType.type } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt index cffab96b066..84912827745 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt @@ -76,7 +76,7 @@ fun ConeKotlinType.canHaveUndefinedNullability(): Boolean { private fun ConeTypeParameterType.hasNotNullUpperBound(): Boolean { return lookupTag.typeParameterSymbol.fir.bounds.any { - val boundType = it.coneTypeUnsafe() + val boundType = it.coneType if (boundType is ConeTypeParameterType) { boundType.hasNotNullUpperBound() } else { @@ -195,7 +195,7 @@ internal fun FirTypeProjection.toConeTypeProjection(): ConeTypeProjection = when (this) { is FirStarProjection -> ConeStarProjection is FirTypeProjectionWithVariance -> { - val type = (this.typeRef as FirResolvedTypeRef).type + val type = typeRef.coneType type.toTypeProjection(this.variance) } else -> error("!") 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 aad08b2abad..0819c0d5ba5 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 @@ -21,6 +21,7 @@ inline fun FirTypeRef.coneTypeSafe(): T? { } return (this as? FirResolvedTypeRef)?.type as? T } +inline val FirTypeRef.coneType: ConeKotlinType get() = coneTypeUnsafe() val FirTypeRef.isAny: Boolean get() = isBuiltinType(StandardClassIds.Any, false) val FirTypeRef.isNullableAny: Boolean get() = isBuiltinType(StandardClassIds.Any, true) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/FirAnalysisSession.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/FirAnalysisSession.kt index 183ae120e62..7dd4a0458f1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/FirAnalysisSession.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/FirAnalysisSession.kt @@ -75,12 +75,12 @@ class FirAnalysisSession( override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): TypeInfo { assertIsValid() val firDeclaration = declaration.getOrBuildFirOfType>() - return firDeclaration.returnTypeRef.coneTypeUnsafe().asTypeInfo(declaration.session) + return firDeclaration.returnTypeRef.coneType.asTypeInfo(declaration.session) } override fun getKtExpressionType(expression: KtExpression): TypeInfo { assertIsValid() - return expression.getOrBuildFirOfType().typeRef.coneTypeUnsafe().asTypeInfo(expression.session) + return expression.getOrBuildFirOfType().typeRef.coneType.asTypeInfo(expression.session) } override fun isSubclassOf(klass: KtClassOrObject, superClassId: ClassId): Boolean { diff --git a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenVisibilityTransformer.kt b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenVisibilityTransformer.kt index 796555ee007..628073f1e55 100644 --- a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenVisibilityTransformer.kt +++ b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenVisibilityTransformer.kt @@ -7,8 +7,6 @@ package org.jetbrains.kotlin.fir.plugin import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.fir.FirEffectiveVisibility -import org.jetbrains.kotlin.fir.FirEffectiveVisibilityImpl import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration