From 5f3a01c25a39d0f63020181cf7af9705e755f04e Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 7 Mar 2019 12:24:03 +0300 Subject: [PATCH] Get rid of FirElement.session usages inside fir:java --- .../kotlin/fir/java/JavaSymbolProvider.kt | 32 ++++++------- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 8 ++-- .../enhancement/EnhancementSignatureParts.kt | 19 ++++---- .../FirAnnotationTypeQualifierResolver.kt | 5 +- .../fir/java/enhancement/javaTypeUtils.kt | 4 +- .../java/scopes/JavaClassEnhancementScope.kt | 46 +++++++++---------- .../fir/java/scopes/JavaClassUseSiteScope.kt | 2 +- 7 files changed, 58 insertions(+), 58 deletions(-) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt index 543e4b97bc1..5ef6f0ff9e2 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt @@ -80,11 +80,11 @@ class JavaSymbolProvider( isTopLevel = classId.relativeClassName.parent().isRoot, isStatic = javaClass.isStatic ).apply { for (typeParameter in javaClass.typeParameters) { - typeParameters += createTypeParameterSymbol(session, typeParameter.name).fir + typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir } - addAnnotationsFrom(javaClass) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass) for (supertype in javaClass.supertypes) { - superTypeRefs += supertype.toFirResolvedTypeRef(session) + superTypeRefs += supertype.toFirResolvedTypeRef(this@JavaSymbolProvider.session) } // TODO: may be we can process fields & methods later. // However, they should be built up to override resolve stage @@ -94,13 +94,13 @@ class JavaSymbolProvider( val fieldSymbol = FirFieldSymbol(fieldId) val returnType = javaField.type val firJavaField = FirJavaField( - session, fieldSymbol, fieldName, + this@JavaSymbolProvider.session, fieldSymbol, fieldName, javaField.visibility, javaField.modality, - returnTypeRef = returnType.toFirJavaTypeRef(session), + returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session), isVar = !javaField.isFinal, isStatic = javaField.isStatic ).apply { - addAnnotationsFrom(javaField) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaField) } declarations += firJavaField } @@ -110,17 +110,17 @@ class JavaSymbolProvider( val methodSymbol = FirFunctionSymbol(methodId) val returnType = javaMethod.returnType val firJavaMethod = FirJavaMethod( - session, methodSymbol, methodName, + this@JavaSymbolProvider.session, methodSymbol, methodName, javaMethod.visibility, javaMethod.modality, - returnTypeRef = returnType.toFirJavaTypeRef(session), + returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session), isStatic = javaMethod.isStatic ).apply { for (typeParameter in javaMethod.typeParameters) { - typeParameters += createTypeParameterSymbol(session, typeParameter.name).fir + typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir } - addAnnotationsFrom(javaMethod) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaMethod) for (valueParameter in javaMethod.valueParameters) { - valueParameters += valueParameter.toFirValueParameters(session) + valueParameters += valueParameter.toFirValueParameters(this@JavaSymbolProvider.session) } } declarations += firJavaMethod @@ -129,19 +129,19 @@ class JavaSymbolProvider( val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName) val constructorSymbol = FirFunctionSymbol(constructorId) val firJavaConstructor = FirJavaConstructor( - session, constructorSymbol, javaConstructor.visibility, + this@JavaSymbolProvider.session, constructorSymbol, javaConstructor.visibility, FirResolvedTypeRefImpl( - session, null, + this@JavaSymbolProvider.session, null, firSymbol.constructType(emptyArray(), false), false, emptyList() ) ).apply { for (typeParameter in javaConstructor.typeParameters) { - typeParameters += createTypeParameterSymbol(session, typeParameter.name).fir + typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir } - addAnnotationsFrom(javaConstructor) + addAnnotationsFrom(this@JavaSymbolProvider.session, javaConstructor) for (valueParameter in javaConstructor.valueParameters) { - valueParameters += valueParameter.toFirValueParameters(session) + valueParameters += valueParameter.toFirValueParameters(this@JavaSymbolProvider.session) } } declarations += firJavaConstructor 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 26ac1d0ed70..e1ef4011e7b 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 @@ -60,7 +60,7 @@ internal fun ClassId.toConeKotlinType( return ConeClassTypeImpl(lookupTag, typeArguments, isNullable) } -internal fun FirTypeRef.toNotNullConeKotlinType(): ConeKotlinType = +internal fun FirTypeRef.toNotNullConeKotlinType(session: FirSession): ConeKotlinType = when (this) { is FirResolvedTypeRef -> type is FirJavaTypeRef -> { @@ -159,7 +159,7 @@ internal fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotat return FirAnnotationCallImpl( session, psi = null, useSiteTarget = null, annotationTypeRef = FirResolvedTypeRefImpl( - session = session, + session, psi = null, type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false), isMarkedNullable = true, @@ -172,7 +172,7 @@ internal fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotat } } -internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(javaAnnotationOwner: JavaAnnotationOwner) { +internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(session: FirSession, javaAnnotationOwner: JavaAnnotationOwner) { for (annotation in javaAnnotationOwner.annotations) { annotations += annotation.toFirAnnotationCall(session) } @@ -184,7 +184,7 @@ internal fun JavaValueParameter.toFirValueParameters(session: FirSession): FirVa returnTypeRef = type.toFirJavaTypeRef(session), isVararg = isVararg ).apply { - addAnnotationsFrom(this@toFirValueParameters) + addAnnotationsFrom(session, this@toFirValueParameters) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt index 84853ad6288..bda99deef11 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.java.enhancement import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer @@ -41,10 +42,11 @@ internal class EnhancementSignatureParts( ((this as? ConeLookupTagBasedType)?.lookupTag as? ConeClassLikeLookupTag)?.classId?.asSingleFqName()?.toUnsafe() internal fun enhance( + session: FirSession, jsr305State: Jsr305State, predefined: TypeEnhancementInfo? = null ): PartEnhancementResult { - val qualifiers = computeIndexedQualifiersForOverride(jsr305State) + val qualifiers = computeIndexedQualifiersForOverride(session, jsr305State) val qualifiersWithPredefined = predefined?.let { IndexedJavaTypeQualifiers(qualifiers.size) { index -> @@ -52,7 +54,7 @@ internal class EnhancementSignatureParts( } } - val containsFunctionN = current.toNotNullConeKotlinType().contains { + val containsFunctionN = current.toNotNullConeKotlinType(session).contains { if (it is ConeClassErrorType) false else { val classId = it.lookupTag.classId @@ -61,7 +63,7 @@ internal class EnhancementSignatureParts( } } - val enhancedCurrent = current.enhance(qualifiersWithPredefined ?: qualifiers) + val enhancedCurrent = current.enhance(session, qualifiersWithPredefined ?: qualifiers) return PartEnhancementResult( enhancedCurrent, wereChanges = true, containsFunctionN = containsFunctionN ) @@ -133,7 +135,7 @@ internal class EnhancementSignatureParts( ) } - private fun FirTypeRef.extractQualifiers(): JavaTypeQualifiers { + private fun FirTypeRef.extractQualifiers(session: FirSession): JavaTypeQualifiers { val (lower, upper) = when (this) { is FirResolvedTypeRef -> { val type = this.type @@ -214,16 +216,17 @@ internal class EnhancementSignatureParts( } private fun FirTypeRef.computeQualifiersForOverride( + session: FirSession, fromSupertypes: Collection, defaultQualifiersForType: JavaTypeQualifiers?, isHeadTypeConstructor: Boolean, jsr305State: Jsr305State ): JavaTypeQualifiers { - val superQualifiers = fromSupertypes.map { it.extractQualifiers() } + val superQualifiers = fromSupertypes.map { it.extractQualifiers(session) } val mutabilityFromSupertypes = superQualifiers.mapNotNull { it.mutability }.toSet() val nullabilityFromSupertypes = superQualifiers.mapNotNull { it.nullability }.toSet() val nullabilityFromSupertypesWithWarning = fromOverridden - .mapNotNull { it.extractQualifiers().nullability } + .mapNotNull { it.extractQualifiers(session).nullability } .toSet() val own = extractQualifiersFromAnnotations(isHeadTypeConstructor, defaultQualifiersForType, jsr305State) @@ -260,7 +263,7 @@ internal class EnhancementSignatureParts( ) } - private fun computeIndexedQualifiersForOverride(jsr305State: Jsr305State): IndexedJavaTypeQualifiers { + private fun computeIndexedQualifiersForOverride(session: FirSession, jsr305State: Jsr305State): IndexedJavaTypeQualifiers { val indexedFromSupertypes = fromOverridden.map { it.toIndexed(typeQualifierResolver, jsr305State, context) } val indexedThisType = current.toIndexed(typeQualifierResolver, jsr305State, context) @@ -280,7 +283,7 @@ internal class EnhancementSignatureParts( val verticalSlice = indexedFromSupertypes.mapNotNull { it.getOrNull(index)?.type } // Only the head type constructor is safely co-variant - qualifiers.computeQualifiersForOverride(verticalSlice, defaultQualifiers, isHeadTypeConstructor, jsr305State) + qualifiers.computeQualifiersForOverride(session, verticalSlice, defaultQualifiers, isHeadTypeConstructor, jsr305State) } return IndexedJavaTypeQualifiers(computedResult) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt index d83c0ec1127..3cf337d44d0 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.java.enhancement import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.toSymbol @@ -16,7 +17,7 @@ import org.jetbrains.kotlin.utils.Jsr305State import org.jetbrains.kotlin.utils.ReportLevel import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult -class FirAnnotationTypeQualifierResolver(private val jsr305State: Jsr305State) { +class FirAnnotationTypeQualifierResolver(private val session: FirSession, private val jsr305State: Jsr305State) { class TypeQualifierWithApplicability( private val typeQualifier: FirAnnotationCall, @@ -48,7 +49,7 @@ class FirAnnotationTypeQualifierResolver(private val jsr305State: Jsr305State) { } private val FirAnnotationCall.resolvedClass: FirRegularClass? - get() = (coneClassLikeType?.lookupTag?.toSymbol(session) as? FirClassSymbol)?.fir + get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirClassSymbol)?.fir fun resolveTypeQualifierAnnotation(annotationCall: FirAnnotationCall): FirAnnotationCall? { if (jsr305State.disabled) { 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 734c7dc6a7e..e083461aef7 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 @@ -46,9 +46,7 @@ internal class IndexedJavaTypeQualifiers(private val data: Array - with(valueParameter) { - FirValueParameterImpl( - session, psi, - this.name, newTypeRef, - defaultValue, isCrossinline, isNoinline, isVararg - ).apply { - annotations += valueParameter.annotations - } + FirMemberFunctionImpl( + this@JavaClassEnhancementScope.session, null, symbol, name, + newReceiverTypeRef, newReturnTypeRef + ).apply { + status = firMethod.status as FirDeclarationStatusImpl + annotations += firMethod.annotations + valueParameters += firMethod.valueParameters.zip(newValueParameterTypeRefs) { valueParameter, newTypeRef -> + with(valueParameter) { + FirValueParameterImpl( + this@JavaClassEnhancementScope.session, psi, + this.name, newTypeRef, + defaultValue, isCrossinline, isNoinline, isVararg + ).apply { + annotations += valueParameter.annotations } } } @@ -198,7 +196,7 @@ class JavaClassEnhancementScope( parameterContainer = ownerFunction, methodContext = memberContext, typeInSignature = TypeInSignature.Receiver - ).enhance(jsr305State) + ).enhance(session, jsr305State) return signatureParts.type } @@ -214,7 +212,7 @@ class JavaClassEnhancementScope( parameterContainer = ownerParameter, methodContext = memberContext, typeInSignature = TypeInSignature.ValueParameter(index) - ).enhance(jsr305State, predefinedEnhancementInfo?.parametersInfo?.getOrNull(index)) + ).enhance(session, jsr305State, predefinedEnhancementInfo?.parametersInfo?.getOrNull(index)) return signatureParts.type } @@ -231,7 +229,7 @@ class JavaClassEnhancementScope( if (owner is FirJavaField) AnnotationTypeQualifierResolver.QualifierApplicabilityType.FIELD else AnnotationTypeQualifierResolver.QualifierApplicabilityType.METHOD_RETURN_TYPE, typeInSignature = TypeInSignature.Return - ).enhance(jsr305State, predefinedEnhancementInfo?.returnTypeInfo) + ).enhance(session, jsr305State, predefinedEnhancementInfo?.returnTypeInfo) return signatureParts.type } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt index 86a9361cdf8..ce8c1bff279 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt @@ -40,7 +40,7 @@ class JavaClassUseSiteScope( } private fun isEqualTypes(a: FirTypeRef, b: FirTypeRef) = - isEqualTypes(a.toNotNullConeKotlinType(), b.toNotNullConeKotlinType()) + isEqualTypes(a.toNotNullConeKotlinType(session), b.toNotNullConeKotlinType(session)) private fun isOverriddenFunCheck(member: FirNamedFunction, self: FirNamedFunction): Boolean { return member.valueParameters.size == self.valueParameters.size &&