From c3632487d0632d135b8846a7a53c3a125681c9ce Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 10 Apr 2019 21:22:22 +0300 Subject: [PATCH] FIR Java: improve symbol provider laziness --- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 13 +++++---- .../fir/java/enhancement/javaTypeUtils.kt | 29 +++++++------------ .../kotlin/fir/resolve/ResolveUtils.kt | 12 ++++++++ 3 files changed, 31 insertions(+), 23 deletions(-) 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 63227a8c097..b2d278645f3 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 @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider -import org.jetbrains.kotlin.fir.resolve.constructType +import org.jetbrains.kotlin.fir.resolve.constructClassType import org.jetbrains.kotlin.fir.resolve.getClassDeclaredCallableSymbols import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl @@ -133,12 +133,15 @@ internal fun JavaClassifierType.toConeKotlinTypeWithNullability(session: FirSess return when (val classifier = classifier) { is JavaClass -> { val classId = classifier.classId!! - val symbol = session.service().getClassLikeSymbolByFqName(classId) as? FirClassSymbol - symbol?.constructType( + val lookupTag = ConeClassLikeLookupTagImpl(classId) + lookupTag.constructClassType( typeArguments.mapIndexed { index, argument -> - argument.toConeProjection(session, symbol.fir.typeParameters.getOrNull(index)) + argument.toConeProjection( + session, null + //symbol.fir.typeParameters.getOrNull(index) + ) }.toTypedArray(), isNullable - ) ?: ConeClassErrorType("Symbol not found, for `$classId`") + ) } is JavaTypeParameter -> { // TODO: it's unclear how to identify type parameter by the symbol 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 2c55493db39..a7f92e4fce6 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 @@ -21,16 +21,10 @@ import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference -import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.constructType import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.resolve.toTypeProjection -import org.jetbrains.kotlin.fir.service -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag -import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.* import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl @@ -137,7 +131,7 @@ private fun JavaClassifierType.enhanceInflexibleType( qualifiers: IndexedJavaTypeQualifiers, index: Int ): ConeLookupTagBasedType { - val originalSymbol = when (val classifier = classifier) { + val originalTag = when (val classifier = classifier) { is JavaClass -> { val classId = classifier.classId!! var mappedId = JavaToKotlinClassMap.mapJavaToKotlin(classId.asSingleFqName()) @@ -147,15 +141,14 @@ private fun JavaClassifierType.enhanceInflexibleType( } } val kotlinClassId = mappedId ?: classId - session.service().getClassLikeSymbolByFqName(kotlinClassId) - ?: return ConeClassErrorType("Cannot find class-like symbol for $kotlinClassId during enhancement") + ConeClassLikeLookupTagImpl(kotlinClassId) } is JavaTypeParameter -> createTypeParameterSymbol(session, classifier.name) else -> return toNotNullConeKotlinType(session) } val effectiveQualifiers = qualifiers(index) - val enhancedSymbol = originalSymbol.enhanceMutability(effectiveQualifiers, position) + val enhancedTag = originalTag.enhanceMutability(effectiveQualifiers, position) var globalArgIndex = index + 1 val enhancedArguments = arguments.mapIndexed { localArgIndex, arg -> @@ -163,7 +156,7 @@ private fun JavaClassifierType.enhanceInflexibleType( globalArgIndex++ arg.toConeProjection( session, - ((originalSymbol as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex) + ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex) ) } else { val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, annotations, qualifiers, globalArgIndex) @@ -174,7 +167,7 @@ private fun JavaClassifierType.enhanceInflexibleType( val enhancedNullability = getEnhancedNullability(effectiveQualifiers, position) - val enhancedType = enhancedSymbol.constructType(enhancedArguments.toTypedArray(), enhancedNullability) + val enhancedType = enhancedTag.constructType(enhancedArguments.toTypedArray(), enhancedNullability) // TODO: why all of these is needed // val enhancement = if (effectiveQualifiers.isNotNullTypeParameter) NotNullTypeParameter(enhancedType) else enhancedType @@ -197,24 +190,24 @@ private fun getEnhancedNullability( } } -private fun ConeClassifierSymbol.enhanceMutability( +private fun ConeClassifierLookupTag.enhanceMutability( qualifiers: JavaTypeQualifiers, position: TypeComponentPosition -): ConeClassifierSymbol { +): ConeClassifierLookupTag { if (!position.shouldEnhance()) return this - if (this !is FirClassSymbol) return this // mutability is not applicable for type parameters + if (this !is ConeClassLikeLookupTag) return this // mutability is not applicable for type parameters when (qualifiers.mutability) { MutabilityQualifier.READ_ONLY -> { val readOnlyId = classId.mutableToReadOnly() if (position == TypeComponentPosition.FLEXIBLE_LOWER && readOnlyId != null) { - return FirClassSymbol(readOnlyId) + return ConeClassLikeLookupTagImpl(readOnlyId) } } MutabilityQualifier.MUTABLE -> { val mutableId = classId.readOnlyToMutable() if (position == TypeComponentPosition.FLEXIBLE_UPPER && mutableId != null) { - return FirClassSymbol(mutableId) + return ConeClassLikeLookupTagImpl(mutableId) } } } 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 699fbc2a145..cd642961150 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 @@ -45,6 +45,18 @@ fun ConeClassifierLookupTag.toSymbol(useSiteSession: FirSession): ConeClassifier else -> error("sealed") } +fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array, isNullable: Boolean): ConeLookupTagBasedType { + return ConeClassTypeImpl(this, typeArguments, isNullable) +} + +fun ConeClassifierLookupTag.constructType(typeArguments: Array, isNullable: Boolean): ConeLookupTagBasedType { + return when (this) { + is ConeTypeParameterLookupTag -> ConeTypeParameterTypeImpl(this, isNullable) + is ConeClassLikeLookupTag -> this.constructClassType(typeArguments, isNullable) + else -> error("! ${this::class}") + } +} + fun ConeClassifierSymbol.constructType(typeArguments: Array, isNullable: Boolean): ConeLookupTagBasedType { return when (this) { is ConeTypeParameterSymbol -> {